期权做市商策略详解：从Delta对冲到Gamma Scalping

import numpy as np
import pandas as pd
from scipy.stats import norm
from typing import List, Tuple

class DeltaHedger:
    """Delta动态对冲模拟器"""
    
    def __init__(self, S0: float, K: float, T: float, r: float, sigma: float):
        """
        初始化参数
        S0: 初始标的资产价格
        K: 期权行权价
        T: 期权剩余期限（年）
        r: 无风险利率
        sigma: 波动率
        """
        self.S0 = S0
        self.K = K
        self.T = T
        self.r = r
        self.sigma = sigma
        
    def black_scholes_delta(self, S: float, t: float, option_type: str = 'call') -> float:
        """计算Black-Scholes Delta"""
        T_remaining = self.T - t
        if T_remaining <= 0:
            return 1.0 if option_type == 'call' and S > self.K else 0.0
        
        d1 = (np.log(S / self.K) + (self.r + 0.5 * self.sigma**2) * T_remaining) / (self.sigma * np.sqrt(T_remaining))
        
        if option_type == 'call':
            return norm.cdf(d1)
        else:
            return norm.cdf(d1) - 1
    
    def simulate_hedging(self, n_steps: int = 100, rebalance_freq: int = 1) -> pd.DataFrame:
        """
        模拟Delta对冲过程
        n_steps: 模拟步数
        rebalance_freq: 再平衡频率（每N步调整一次）
        """
        dt = self.T / n_steps
        results = []
        
        # 生成标的资产价格路径（几何布朗运动）
        S_path = [self.S0]
        for i in range(1, n_steps + 1):
            dW = np.random.normal(0, np.sqrt(dt))
            S_new = S_path[-1] * np.exp((self.r - 0.5 * self.sigma**2) * dt + self.sigma * dW)
            S_path.append(S_new)
        
        # 初始状态
        t = 0
        S = self.S0
        delta = self.black_scholes_delta(S, t)
        hedge_shares = -delta  # 对冲头寸（卖出期权，所以做空Delta）
        cash = delta * S  # 用于对冲的现金
        
        results.append({
            'step': 0,
            'time': t,
            'S': S,
            'delta': delta,
            'hedge_shares': hedge_shares,
            'cash': cash,
            'option_value': self.black_scholes_price(S, t, 'call')
        })
        
        # 动态对冲循环
        for i in range(1, n_steps + 1):
            t = i * dt
            S = S_path[i]
            
            # 是否需要再平衡
            if i % rebalance_freq == 0:
                old_delta = delta
                delta = self.black_scholes_delta(S, t)
                new_hedge_shares = -delta
                
                # 调整对冲头寸
                shares_diff = new_hedge_shares - hedge_shares
                cash -= shares_diff * S  # 买入为正，卖出为负
                hedge_shares = new_hedge_shares
            
            # 记录状态
            option_value = self.black_scholes_price(S, t, 'call')
            results.append({
                'step': i,
                'time': t,
                'S': S,
                'delta': delta,
                'hedge_shares': hedge_shares,
                'cash': cash,
                'option_value': option_value
            })
        
        return pd.DataFrame(results)
    
    def black_scholes_price(self, S: float, t: float, option_type: str = 'call') -> float:
        """计算Black-Scholes期权价格"""
        T_remaining = self.T - t
        if T_remaining <= 0:
            return max(S - self.K, 0) if option_type == 'call' else max(self.K - S, 0)
        
        d1 = (np.log(S / self.K) + (self.r + 0.5 * self.sigma**2) * T_remaining) / (self.sigma * np.sqrt(T_remaining))
        d2 = d1 - self.sigma * np.sqrt(T_remaining)
        
        if option_type == 'call':
            return S * norm.cdf(d1) - self.K * np.exp(-self.r * T_remaining) * norm.cdf(d2)
        else:
            return self.K * np.exp(-self.r * T_remaining) * norm.cdf(-d2) - S * norm.cdf(-d1)

# 使用示例
hedger = DeltaHedger(S0=100, K=100, T=1.0, r=0.05, sigma=0.25)
results = hedger.simulate_hedging(n_steps=252, rebalance_freq=5)

print(f"初始Delta: {results['delta'].iloc[0]:.4f}")
print(f"最终对冲损益: {results['cash'].iloc[-1] + results['hedge_shares'].iloc[-1] * results['S'].iloc[-1] - results['option_value'].iloc[-1]:.2f}")

class GammaScalper:
    """Gamma Scalping策略模拟器"""
    
    def __init__(self, S0: float, K: float, T: float, r: float, sigma: float):
        self.S0 = S0
        self.K = K
        self.T = T
        self.r = r
        self.sigma = sigma
        
    def black_scholes_gamma(self, S: float, t: float) -> float:
        """计算Black-Scholes Gamma"""
        T_remaining = self.T - t
        if T_remaining <= 0:
            return 0.0
        
        d1 = (np.log(S / self.K) + (self.r + 0.5 * self.sigma**2) * T_remaining) / (self.sigma * np.sqrt(T_remaining))
        return norm.pdf(d1) / (S * self.sigma * np.sqrt(T_remaining))
    
    def simulate_gamma_scalping(self, n_steps: int = 100, transaction_cost: float = 0.01) -> pd.DataFrame:
        """
        模拟Gamma Scalping策略
        transaction_cost: 交易成本（每笔交易占交易金额的比例）
        """
        dt = self.T / n_steps
        results = []
        
        # 生成震荡行情价格路径
        S_path = [self.S0]
        for i in range(1, n_steps + 1):
            # 添加均值回归特性
            mean_reversion_force = 0.1 * (self.S0 - S_path[-1]) / self.S0
            dW = np.random.normal(0, np.sqrt(dt))
            dS = S_path[-1] * (mean_reversion_force + self.sigma * dW)
            S_new = S_path[-1] * (1 + dS)
            S_path.append(S_new)
        
        # 初始状态：买入跨式组合（Long Straddle）
        t = 0
        S = self.S0
        option_value = self.black_scholes_price(S, t, 'call') + self.black_scholes_price(S, t, 'put')
        delta = self.black_scholes_delta(S, t, 'call') + self.black_scholes_delta(S, t, 'put')
        gamma = self.black_scholes_gamma(S, t) * 2
        
        # 对冲账户
        hedge_shares = -delta  # 初始对冲
        cash = delta * S
        total_cost = 0  # 累积交易成本
        
        results.append({
            'step': 0,
            'time': t,
            'S': S,
            'delta': delta,
            'gamma': gamma,
            'hedge_shares': hedge_shares,
            'cash': cash,
            'option_value': option_value,
            'pnl': 0,
            'transaction_cost': 0
        })
        
        # Gamma Scalping循环
        for i in range(1, n_steps + 1):
            t = i * dt
            S = S_path[i]
            
            # 计算新的Greeks
            option_value = self.black_scholes_price(S, t, 'call') + self.black_scholes_price(S, t, 'put')
            new_delta = self.black_scholes_delta(S, t, 'call') + self.black_scholes_delta(S, t, 'put')
            gamma = self.black_scholes_gamma(S, t) * 2
            
            # 调整对冲头寸
            shares_diff = (-new_delta) - hedge_shares
            transaction_cost_amount = abs(shares_diff * S * transaction_cost)
            cash -= shares_diff * S + transaction_cost_amount
            total_cost += transaction_cost_amount
            hedge_shares = -new_delta
            
            # 计算当前损益
            hedge_pnl = cash + hedge_shares * S - results[-1]['cash'] - results[-1]['hedge_shares'] * results[-1]['S']
            option_pnl = option_value - results[-1]['option_value']
            total_pnl = hedge_pnl + option_pnl - transaction_cost_amount
            
            results.append({
                'step': i,
                'time': t,
                'S': S,
                'delta': new_delta,
                'gamma': gamma,
                'hedge_shares': hedge_shares,
                'cash': cash,
                'option_value': option_value,
                'pnl': total_pnl,
                'transaction_cost': transaction_cost_amount
            })
        
        return pd.DataFrame(results)
    
    def black_scholes_delta(self, S: float, t: float, option_type: str) -> float:
        """计算Delta"""
        T_remaining = self.T - t
        if T_remaining <= 0:
            return 0.0
        
        d1 = (np.log(S / self.K) + (self.r + 0.5 * self.sigma**2) * T_remaining) / (self.sigma * np.sqrt(T_remaining))
        return norm.cdf(d1) if option_type == 'call' else norm.cdf(d1) - 1
    
    def black_scholes_price(self, S: float, t: float, option_type: str) -> float:
        """计算期权价格"""
        T_remaining = self.T - t
        if T_remaining <= 0:
            return max(S - self.K, 0) if option_type == 'call' else max(self.K - S, 0)
        
        d1 = (np.log(S / self.K) + (self.r + 0.5 * self.sigma**2) * T_remaining) / (self.sigma * np.sqrt(T_remaining))
        d2 = d1 - self.sigma * np.sqrt(T_remaining)
        
        if option_type == 'call':
            return S * norm.cdf(d1) - self.K * np.exp(-self.r * T_remaining) * norm.cdf(d2)
        else:
            return self.K * np.exp(-self.r * T_remaining) * norm.cdf(-d2) - S * norm.cdf(-d1)

# 使用示例
scalper = GammaScalper(S0=100, K=100, T=1.0, r=0.05, sigma=0.25)
results = scalper.simulate_gamma_scalping(n_steps=252, transaction_cost=0.001)

cum_pnl = results['pnl'].cumsum()
print(f"Gamma Scalping总收益: {cum_pnl.iloc[-1]:.2f}")
print(f"总交易成本: {results['transaction_cost'].sum():.2f}")

class VolatilityArbitrage:
    """波动率套利策略模拟器"""
    
    def __init__(self, S0: float, K: float, T: float, r: float):
        self.S0 = S0
        self.K = K
        self.T = T
        self.r = r
        
    def calculate_implied_volatility(self, option_price: float, S: float, t: float, option_type: str) -> float:
        """通过牛顿迭代法计算隐含波动率"""
        sigma_guess = 0.3
        tolerance = 1e-6
        max_iterations = 100
        
        for i in range(max_iterations):
            price = self.bs_price(S, t, sigma_guess, option_type)
            vega = self.bs_vega(S, t, sigma_guess)
            
            if abs(vega) < 1e-10:
                break
            
            sigma_new = sigma_guess - (price - option_price) / vega
            
            if abs(sigma_new - sigma_guess) < tolerance:
                return sigma_new
            
            sigma_guess = sigma_new
        
        return sigma_guess
    
    def bs_price(self, S: float, t: float, sigma: float, option_type: str) -> float:
        """Black-Scholes价格"""
        T_remaining = self.T - t
        if T_remaining <= 0:
            return max(S - self.K, 0) if option_type == 'call' else max(self.K - S, 0)
        
        d1 = (np.log(S / self.K) + (self.r + 0.5 * sigma**2) * T_remaining) / (sigma * np.sqrt(T_remaining))
        d2 = d1 - sigma * np.sqrt(T_remaining)
        
        if option_type == 'call':
            return S * norm.cdf(d1) - self.K * np.exp(-self.r * T_remaining) * norm.cdf(d2)
        else:
            return self.K * np.exp(-self.r * T_remaining) * norm.cdf(-d2) - S * norm.cdf(-d1)
    
    def bs_vega(self, S: float, t: float, sigma: float) -> float:
        """Black-Scholes Vega"""
        T_remaining = self.T - t
        if T_remaining <= 0:
            return 0.0
        
        d1 = (np.log(S / self.K) + (self.r + 0.5 * sigma**2) * T_remaining) / (sigma * np.sqrt(T_remaining))
        return S * norm.pdf(d1) * np.sqrt(T_remaining)
    
    def calculate_realized_volatility(self, price_path: List[float], window: int = 20) -> float:
        """计算实际波动率（滚动窗口）"""
        log_returns = np.diff(np.log(price_path))
        if len(log_returns) < window:
            return np.std(log_returns) * np.sqrt(252)
        
        recent_returns = log_returns[-window:]
        return np.std(recent_returns) * np.sqrt(252)
    
    def volatility_arbitrage_signal(self, S: float, t: float, option_market_price: float, 
                                   price_path: List[float], option_type: str = 'call') -> str:
        """
        生成波动率套利信号
        返回: 'buy', 'sell', 或 'hold'
        """
        # 计算隐含波动率
        iv = self.calculate_implied_volatility(option_market_price, S, t, option_type)
        
        # 计算实际波动率
        rv = self.calculate_realized_volatility(price_path)
        
        # 生成交易信号
        if iv > rv * 1.1:  # IV显著高于RV
            return 'sell'  # 卖出期权（做空波动率）
        elif iv < rv * 0.9:  # IV显著低于RV
            return 'buy'   # 买入期权（做多波动率）
        else:
            return 'hold'

# 使用示例
va = VolatilityArbitrage(S0=100, K=100, T=1.0, r=0.05)

# 模拟市场数据
S_current = 102
option_market_price = 5.5  # 市场价格
price_history = [100, 101, 99, 102, 103, 101, 104, 102, 100, 103, 105, 102]

signal = va.volatility_arbitrage_signal(S_current, 0.5, option_market_price, price_history, 'call')
print(f"当前标的价格: {S_current}")
print(f"期权市场价格: {option_market_price}")
print(f"套利信号: {signal}")

class RiskManager:
    """Greeks风险管理器"""
    
    def __init__(self):
        self.limits = {
            'delta': 1000,      # Delta限额
            'gamma': 500,      # Gamma限额
            'vega': 10000,     # Vega限额（美元/波动率点）
            'theta': -5000,    # Theta限额（每日时间衰减）
        }
        
    def check_risk_limits(self, portfolio_greeks: dict) -> Tuple[bool, List[str]]:
        """
        检查投资组合是否超出风险限额
        返回: (是否合规, 违规项目列表)
        """
        violations = []
        
        if abs(portfolio_greeks.get('delta', 0)) > self.limits['delta']:
            violations.append(f"Delta超限: {portfolio_greeks['delta']}")
        
        if abs(portfolio_greeks.get('gamma', 0)) > self.limits['gamma']:
            violations.append(f"Gamma超限: {portfolio_greeks['gamma']}")
        
        if abs(portfolio_greeks.get('vega', 0)) > self.limits['vega']:
            violations.append(f"Vega超限: {portfolio_greeks['vega']}")
        
        if portfolio_greeks.get('theta', 0) < self.limits['theta']:
            violations.append(f"Theta超限: {portfolio_greeks['theta']}")
        
        return len(violations) == 0, violations
    
    def suggest_hedge(self, portfolio_greeks: dict) -> dict:
        """根据Greeks暴露建议对冲操作"""
        suggestions = {}
        
        if portfolio_greeks.get('delta', 0) > self.limits['delta'] * 0.8:
            suggestions['delta_hedge'] = f"卖出{portfolio_greeks['delta']}股标的资产"
        
        if portfolio_greeks.get('vega', 0) > self.limits['vega'] * 0.8:
            suggestions['vega_hedge'] = "买入VIX期货或期权对冲波动率风险"
        
        return suggestions

class StressTester:
    """投资组合压力测试器"""
    
    def __init__(self, portfolio_positions: List[dict]):
        """
        portfolio_positions: 持仓列表
        每个持仓包含: {'type': 'call', 'strike': 100, 'quantity': 10, 'maturity': 0.5}
        """
        self.positions = portfolio_positions
        
    def scenario_analysis(self, scenarios: List[dict]) -> pd.DataFrame:
        """
        情景分析
        scenarios: 情景列表
        每个情景包含: {'name': '市场崩盘', 'spot_shock': -0.3, 'vol_shock': 0.5}
        """
        results = []
        
        for scenario in scenarios:
            total_pnl = 0
            
            for position in self.positions:
                # 计算冲击后的标的资产价格
                S_shocked = position.get('current_price', 100) * (1 + scenario.get('spot_shock', 0))
                
                # 计算冲击后的波动率
                sigma_shocked = position.get('current_vol', 0.25) + scenario.get('vol_shock', 0)
                
                # 估算头寸价值变化（简化版）
                # 实际应用中应使用完整的定价模型
                if position['type'] in ['call', 'put']:
                    delta = position.get('delta', 0.5)
                    gamma = position.get('gamma', 0.01)
                    vega = position.get('vega', 0.2)
                    
                    price_change = (delta * S_shocked * scenario.get('spot_shock', 0) + 
                                   0.5 * gamma * (S_shocked ** 2) * (scenario.get('spot_shock', 0) ** 2) +
                                   vega * scenario.get('vol_shock', 0))
                    
                    pnl = price_change * position['quantity'] * position.get('multiplier', 100)
                    total_pnl += pnl
            
            results.append({
                'scenario': scenario['name'],
                'total_pnl': total_pnl,
                'max_loss': min(total_pnl, 0),
                'max_gain': max(total_pnl, 0)
            })
        
        return pd.DataFrame(results)

# 使用示例
positions = [
    {'type': 'call', 'strike': 100, 'quantity': 10, 'current_price': 100, 'delta': 0.5, 'gamma': 0.02, 'vega': 0.3},
    {'type': 'put', 'strike': 95, 'quantity': -5, 'current_price': 100, 'delta': -0.3, 'gamma': 0.015, 'vega': 0.25}
]

tester = StressTester(positions)

scenarios = [
    {'name': '市场崩盘', 'spot_shock': -0.3, 'vol_shock': 0.5},
    {'name': '牛市爆发', 'spot_shock': 0.2, 'vol_shock': -0.1},
    {'name': '波动率飙升', 'spot_shock': 0.0, 'vol_shock': 0.3},
    {'name': '利率冲击', 'spot_shock': -0.05, 'vol_shock': 0.1}
]

stress_results = tester.scenario_analysis(scenarios)
print(stress_results)

class InventoryManager:
    """库存管理系统"""
    
    def __init__(self, max_position_size: int, max_notional: float):
        """
        max_position_size: 最大持仓合约数
        max_notional: 最大名义本金（美元）
        """
        self.max_position_size = max_position_size
        self.max_notional = max_notional
        self.current_positions = {}
        self.trade_history = []
        
    def add_position(self, symbol: str, quantity: int, price: float, multiplier: int = 100) -> Tuple[bool, str]:
        """
        添加持仓
        返回: (是否成功, 失败原因)
        """
        # 检查持仓数量限制
        current_qty = self.current_positions.get(symbol, {}).get('quantity', 0)
        new_qty = current_qty + quantity
        
        if abs(new_qty) > self.max_position_size:
            return False, f"超出持仓数量限制: {abs(new_qty)} > {self.max_position_size}"
        
        # 检查名义本金限制
        notional = abs(new_qty * price * multiplier)
        total_notional = self.calculate_total_notional()
        
        if total_notional + notional > self.max_notional:
            return False, f"超出名义本金限制: {total_notional + notional:.2f} > {self.max_notional:.2f}"
        
        # 更新持仓
        if symbol not in self.current_positions:
            self.current_positions[symbol] = {'quantity': 0, 'avg_price': 0, 'notional': 0}
        
        pos = self.current_positions[symbol]
        pos['quantity'] = new_qty
        pos['avg_price'] = (pos['avg_price'] * current_qty + price * quantity) / new_qty if new_qty != 0 else 0
        pos['notional'] = abs(new_qty * pos['avg_price'] * multiplier)
        
        # 记录交易
        self.trade_history.append({
            'timestamp': pd.Timestamp.now(),
            'symbol': symbol,
            'quantity': quantity,
            'price': price,
            'notional': abs(quantity * price * multiplier)
        })
        
        return True, "成功"
    
    def calculate_total_notional(self) -> float:
        """计算总名义本金"""
        total = 0
        for symbol, pos in self.current_positions.items():
            total += pos.get('notional', 0)
        return total
    
    def get_position_summary(self) -> pd.DataFrame:
        """生成持仓汇总报告"""
        data = []
        for symbol, pos in self.current_positions.items():
            data.append({
                'symbol': symbol,
                'quantity': pos['quantity'],
                'avg_price': pos['avg_price'],
                'notional': pos['notional'],
                'weight': pos['notional'] / self.calculate_total_notional() * 100 if self.calculate_total_notional() > 0 else 0
            })
        
        return pd.DataFrame(data).sort_values('notional', ascending=False)
    
    def check_concentration_risk(self, threshold: float = 0.2) -> List[str]:
        """
        检查集中度风险
        threshold: 单一持仓占比阈值（默认20%）
        返回: 违规标的列表
        """
        warnings = []
        total_notional = self.calculate_total_notional()
        
        if total_notional == 0:
            return warnings
        
        for symbol, pos in self.current_positions.items():
            weight = pos['notional'] / total_notional
            if weight > threshold:
                warnings.append(f"{symbol}持仓占比{weight*100:.1f}%，超过{threshold*100:.0f}%阈值")
        
        return warnings

# 使用示例
inventory_mgr = InventoryManager(max_position_size=1000, max_notional=1000000)

# 添加持仓
success, msg = inventory_mgr.add_position('AAPL_CALL_100', quantity=100, price=5.0)
print(f"添加持仓: {success}, {msg}")

success, msg = inventory_mgr.add_position('AAPL_PUT_95', quantity=-50, price=3.0)
print(f"添加持仓: {success}, {msg}")

# 查看持仓汇总
print("\n持仓汇总:")
print(inventory_mgr.get_position_summary())

# 检查集中度风险
warnings = inventory_mgr.check_concentration_risk(threshold=0.3)
if warnings:
    print("\n风险警告:")
    for w in warnings:
        print(f"  - {w}")

import numpy as np
from dataclasses import dataclass
from typing import Dict, List

@dataclass
class Option:
    """期权合约数据结构"""
    symbol: str
    underlying: str
    strike: float
    expiry: float  # 距离到期的年数
    option_type: str  # 'call' or 'put'
    underlying_price: float
    
class PricingEngine:
    """期权定价引擎"""
    
    def __init__(self, risk_free_rate: float = 0.05):
        self.risk_free_rate = risk_free_rate
        self.pricing_cache = {}  # 定价缓存
        
    def black_scholes_price(self, option: Option, volatility: float) -> Dict:
        """
        计算Black-Scholes价格及Greeks
        返回: {'price': float, 'delta': float, 'gamma': float, 'theta': float, 'vega': float}
        """
        S = option.underlying_price
        K = option.strike
        T = option.expiry
        r = self.risk_free_rate
        sigma = volatility
        
        if T <= 0:
            price = max(S - K, 0) if option.option_type == 'call' else max(K - S, 0)
            return {
                'price': price,
                'delta': 1.0 if option.option_type == 'call' and S > K else 0.0,
                'gamma': 0.0,
                'theta': 0.0,
                'vega': 0.0
            }
        
        # 计算d1和d2
        d1 = (np.log(S / K) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
        d2 = d1 - sigma * np.sqrt(T)
        
        # 计算价格
        if option.option_type == 'call':
            price = S * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
            delta = norm.cdf(d1)
        else:
            price = K * np.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)
            delta = norm.cdf(d1) - 1
        
        # 计算Greeks
        gamma = norm.pdf(d1) / (S * sigma * np.sqrt(T))
        vega = S * norm.pdf(d1) * np.sqrt(T)
        
        # Theta计算（简化版）
        if option.option_type == 'call':
            theta = (-S * norm.pdf(d1) * sigma / (2 * np.sqrt(T)) 
                     - r * K * np.exp(-r * T) * norm.cdf(d2)) / 365
        else:
            theta = (-S * norm.pdf(d1) * sigma / (2 * np.sqrt(T)) 
                     + r * K * np.exp(-r * T) * norm.cdf(-d2)) / 365
        
        return {
            'price': price,
            'delta': delta,
            'gamma': gamma,
            'theta': theta,
            'vega': vega
        }
    
    def batch_price(self, options: List[Option], volatilities: List[float]) -> pd.DataFrame:
        """批量定价（优化性能）"""
        results = []
        
        for opt, vol in zip(options, volatilities):
            greeks = self.black_scholes_price(opt, vol)
            results.append({
                'symbol': opt.symbol,
                'price': greeks['price'],
                'delta': greeks['delta'],
                'gamma': greeks['gamma'],
                'theta': greeks['theta'],
                'vega': greeks['vega']
            })
        
        return pd.DataFrame(results)

# 使用示例
pricing_engine = PricingEngine(risk_free_rate=0.05)

# 创建期权合约
option1 = Option(
    symbol='AAPL_C100',
    underlying='AAPL',
    strike=100,
    expiry=0.25,  # 3个月
    option_type='call',
    underlying_price=102
)

# 定价
volatility = 0.25  # 25%隐含波动率
greeks = pricing_engine.black_scholes_price(option1, volatility)

print(f"期权价格: {greeks['price']:.2f}")
print(f"Delta: {greeks['delta']:.4f}")
print(f"Gamma: {greeks['gamma']:.4f}")
print(f"Theta: {greeks['theta']:.4f}")
print(f"Vega: {greeks['vega']:.4f}")