Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- # ============================================================
- # BLACK-SCHOLES CALCULATOR — CLI VERSION
- # Curso de Derivados Financieros
- # Ejecutar: python bs_cli.py
- # ============================================================
- # --- Librerías estándar de Python (no requieren instalación) ---
- from math import log, sqrt, exp, erf
- # --- Librería externa para datos reales ---
- # Instalar con: pip install yfinance
- try:
- import yfinance as yf
- YFINANCE_OK = True
- except ImportError:
- YFINANCE_OK = False
- # ============================================================
- # FUNCIÓN AUXILIAR: Distribución Normal Acumulada N(x)
- # ============================================================
- # N(x) nos dice la probabilidad de que una variable normal
- # estándar sea menor o igual a x.
- # Es el corazón de Black-Scholes: pondera las probabilidades
- # de que la opción expire "in the money".
- def N(x):
- """Distribución normal acumulada estándar."""
- return 0.5 * (1 + erf(x / sqrt(2)))
- # ============================================================
- # FUNCIÓN: Densidad Normal (para los Greeks)
- # ============================================================
- def npdf(x):
- """Función de densidad de la distribución normal estándar."""
- return exp(-0.5 * x ** 2) / sqrt(2 * 3.141592653589793)
- # ============================================================
- # FUNCIÓN PRINCIPAL: Precio Black-Scholes + Greeks
- # ============================================================
- def black_scholes(S, K, T, sigma, r):
- """
- Calcula el precio teórico de una opción CALL europea
- usando el modelo de Black-Scholes (1973).
- Parámetros:
- -----------
- S : Precio actual de la acción (S₀)
- K : Strike price — precio pactado de compra
- T : Tiempo al vencimiento en años (ej: 0.25 = 3 meses)
- sigma : Volatilidad anualizada (ej: 0.30 = 30%)
- r : Tasa libre de riesgo anualizada (ej: 0.04 = 4%)
- Retorna:
- --------
- dict con precio de la call y los 4 Greeks principales
- """
- # --- Paso 1: Calcular d1 ---
- # d1 mide cuántas desviaciones estándar está el precio
- # actual por encima del strike, ajustado por tiempo y drift.
- d1 = (log(S / K) + (r + sigma**2 / 2) * T) / (sigma * sqrt(T))
- # --- Paso 2: Calcular d2 ---
- # d2 = d1 menos la volatilidad acumulada hasta el vencimiento.
- # N(d2) ≈ probabilidad real de que la opción expire ITM.
- d2 = d1 - sigma * sqrt(T)
- # --- Paso 3: Precio de la call ---
- # Fórmula: C = S·N(d1) - K·e^(-rT)·N(d2)
- #
- # Intuición:
- # S·N(d1) = valor esperado de recibir la acción si ejerces
- # K·e^(-rT)·N(d2) = valor presente del costo de comprar al strike
- #
- call = S * N(d1) - K * exp(-r * T) * N(d2)
- # --- Paso 4: Greeks ---
- # Los Greeks miden la sensibilidad del precio ante cambios
- # en cada variable del modelo.
- # Delta (Δ): cambio en el precio de la call por cada $1 que sube S.
- # Rango 0 a 1. Cerca de 0.5 cuando S ≈ K (ATM).
- delta = N(d1)
- # Gamma (Γ): velocidad de cambio del delta.
- # Alto cerca del strike → el delta cambia rápido → más riesgo.
- gamma = npdf(d1) / (S * sigma * sqrt(T))
- # Theta (Θ): pérdida de valor por día que pasa (time decay).
- # Siempre negativo para un comprador de opciones.
- theta = (-(S * npdf(d1) * sigma) / (2 * sqrt(T))
- - r * K * exp(-r * T) * N(d2)) / 365
- # Vega (ν): cambio en el precio por cada 1% de aumento en σ.
- # Dividimos entre 100 para expresarlo por 1% de volatilidad.
- vega = S * npdf(d1) * sqrt(T) / 100
- return {
- "call": round(call, 4),
- "delta": round(delta, 4),
- "gamma": round(gamma, 4),
- "theta": round(theta, 4),
- "vega": round(vega, 4),
- "d1": round(d1, 4),
- "d2": round(d2, 4),
- "N_d1": round(N(d1), 4),
- "N_d2": round(N(d2), 4),
- "intrinsic": round(max(0, S - K), 4),
- "time_value": round(max(0, call - max(0, S - K)), 4),
- "breakeven": round(K + call, 4),
- }
- # ============================================================
- # FUNCIÓN: Obtener datos reales desde Yahoo Finance
- # ============================================================
- def get_stock_data(ticker_symbol):
- """
- Descarga precio actual y volatilidad histórica 30 días
- para un ticker dado usando yfinance.
- Requiere: pip install yfinance
- """
- if not YFINANCE_OK:
- print("\n[!] yfinance no instalado. Usa: pip install yfinance")
- return None
- print(f"\nDescargando datos para {ticker_symbol}...")
- try:
- tk = yf.Ticker(ticker_symbol)
- hist = tk.history(period="60d")
- if hist.empty:
- print(f"[!] No se encontraron datos para '{ticker_symbol}'")
- return None
- # Precio actual = último cierre disponible
- price = hist["Close"].iloc[-1]
- # Volatilidad histórica anualizada (30 días de retornos diarios)
- # sqrt(252) anualiza la desviación estándar diaria
- returns = hist["Close"].pct_change().dropna()
- vol = returns.tail(30).std() * sqrt(252)
- info = tk.info
- name = info.get("longName", ticker_symbol)
- return {
- "ticker": ticker_symbol.upper(),
- "name": name,
- "price": round(price, 2),
- "vol": round(vol, 4),
- }
- except Exception as e:
- print(f"[!] Error: {e}")
- return None
- # ============================================================
- # FUNCIÓN: Imprimir resultados en la terminal
- # ============================================================
- def print_results(ticker, S, K, T, sigma, r, res):
- """Muestra los resultados de forma legible en la terminal."""
- # Determinar si la opción está ITM, ATM u OTM
- if S > K * 1.02:
- moneyness = "IN THE MONEY (ITM)"
- elif S < K * 0.98:
- moneyness = "OUT OF THE MONEY (OTM)"
- else:
- moneyness = "AT THE MONEY (ATM)"
- print("\n" + "=" * 55)
- print(f" BLACK-SCHOLES — CALL EUROPEA / {ticker}")
- print("=" * 55)
- print("\n PARÁMETROS DE ENTRADA")
- print(f" S₀ Precio actual : ${S:.2f}")
- print(f" K Strike price : ${K:.2f}")
- print(f" T Tiempo al vto. : {T:.2f} años ({T*12:.1f} meses)")
- print(f" σ Volatilidad : {sigma*100:.1f}%")
- print(f" r Tasa risk-free : {r*100:.2f}%")
- print(f" Moneyness : {moneyness}")
- print("\n CÁLCULO INTERNO")
- print(f" d₁ = {res['d1']:.4f}")
- print(f" d₂ = {res['d2']:.4f}")
- print(f" N(d₁) = {res['N_d1']:.4f} (prob. ajustada por ganancia)")
- print(f" N(d₂) = {res['N_d2']:.4f} (prob. de expirar ITM ≈ {res['N_d2']*100:.1f}%)")
- print("\n PRECIO DE LA CALL")
- print(f" Prima : ${res['call']:.2f}")
- print(f" Valor intrínseco: ${res['intrinsic']:.2f} (max(S-K, 0))")
- print(f" Valor tiempo : ${res['time_value']:.2f} (prima - intrínseco)")
- print(f" Break-even al vto: ${res['breakeven']:.2f} (K + prima)")
- print("\n GREEKS")
- print(f" Δ Delta = {res['delta']:.4f} → si S sube $1, call sube ~${res['delta']:.2f}")
- print(f" Γ Gamma = {res['gamma']:.4f} → velocidad de cambio del delta")
- print(f" Θ Theta = {res['theta']:.4f} → pierde ${abs(res['theta']):.4f}/día")
- print(f" ν Vega = {res['vega']:.4f} → si σ +1%, call +${res['vega']:.2f}")
- print("=" * 55)
- # ============================================================
- # PROGRAMA PRINCIPAL
- # ============================================================
- def main():
- print("\n╔══════════════════════════════════════════╗")
- print("║ BLACK-SCHOLES CALCULATOR — CLI ║")
- print("║ Curso de Derivados Financieros ║")
- print("╚══════════════════════════════════════════╝")
- # Tasa risk-free (aproximación bonos del tesoro USA 3M)
- r = 0.043
- print("\n¿Quieres usar datos reales de mercado? (requiere yfinance)")
- usar_real = input(" [s/n]: ").strip().lower()
- if usar_real == "s" and YFINANCE_OK:
- ticker = input(" Ticker (ej: AAPL, TSLA, NVDA, SPY): ").strip().upper()
- data = get_stock_data(ticker)
- if data:
- S = data["price"]
- sigma = data["vol"]
- print(f"\n {data['name']}")
- print(f" Precio actual : ${S:.2f}")
- print(f" Vol. hist. 30d: {sigma*100:.1f}%")
- else:
- print(" Usando valores de ejemplo.")
- ticker = "EJEMPLO"
- S, sigma = 150.0, 0.30
- else:
- ticker = "MANUAL"
- print("\n Ingresa los parámetros manualmente:")
- S = float(input(" S₀ Precio actual de la acción ($): "))
- sigma = float(input(" σ Volatilidad anual (ej: 0.30 para 30%): "))
- # Strike y tiempo siempre los define el alumno
- print(f"\n Precio actual S₀ = ${S:.2f}")
- K = float(input(f" K Strike price ($, sugerido ~{S*1.05:.0f}): "))
- T = float(input(" T Tiempo al vencimiento en años (ej: 0.25 = 3 meses): "))
- # Calcular
- resultado = black_scholes(S, K, T, sigma, r)
- # Mostrar
- print_results(ticker, S, K, T, sigma, r, resultado)
- # Análisis de sensibilidad simple
- print("\n SENSIBILIDAD — cómo cambia la prima con distintos strikes")
- print(f" {'Strike':>10} {'Prima':>8} {'Moneyness':>12} {'Prob ITM':>10}")
- print(" " + "-" * 46)
- for k_mult in [0.85, 0.90, 0.95, 1.00, 1.05, 1.10, 1.15]:
- k_test = round(S * k_mult, 2)
- r_test = black_scholes(S, k_test, T, sigma, r)
- if S > k_test * 1.02:
- mon = "ITM"
- elif S < k_test * 0.98:
- mon = "OTM"
- else:
- mon = "ATM"
- marker = " <-- tú" if abs(k_test - K) < 1 else ""
- print(f" ${k_test:>9.2f} ${r_test['call']:>7.2f} {mon:>12} {r_test['N_d2']*100:>8.1f}%{marker}")
- print()
- if __name__ == "__main__":
- main()
Advertisement