A entrada que ninguém pode observar
Na fórmula de Black–Scholes o preço à vista, o strike, a taxa e o tempo são conhecidos. A volatilidade não: é a expectativa do mercado sobre o movimento futuro, e muda todo dia. O preço de uma opção depende, portanto, muito de um número que precisa ser adivinhado, e a sensibilidade a ele, o vega, dC/dsigma, costuma ser o maior risco de um livro de opções. No Black–Scholes é S * pdf(d1) * sqrt(T), igual para calls e puts, e positivo: mais volatilidade sempre torna uma opção mais valiosa.
import math
def norm_pdf(x):
return math.exp(-0.5 * x * x) / math.sqrt(2 * math.pi)
def d1(spot, strike, rate, sigma, t):
return (math.log(spot / strike) + (rate + 0.5 * sigma ** 2) * t) / (sigma * math.sqrt(t))
def vega(spot, strike, rate, sigma, t):
return spot * norm_pdf(d1(spot, strike, rate, sigma, t)) * math.sqrt(t)
print(round(vega(100, 100, 0.05, 0.2, 1), 4)) # 37.524 per change of 1.00 in sigma (100 volatility points)
print(round(vega(100, 100, 0.05, 0.2, 1) / 100, 4)) # 0.3752 per volatility point: sigma from 20% to 21%Onde o vega é maior
O vega é máximo para opções no dinheiro, onde o resultado é mais incerto e a volatilidade extra muda mais, e some para opções muito dentro ou fora do dinheiro (strike 80: 23,8; strike 100: 37,5; strike 120: 21,6). Ao contrário do gama, o vega cresce com o prazo até o vencimento: 19,6 para três meses, 37,5 para um ano, 62,5 para quatro anos, porque uma vida mais longa dá mais tempo para a volatilidade importar. Opções de prazo longo são, portanto, as mais expostas a mudanças de volatilidade, enquanto as de prazo curto são as mais expostas ao gama.
for strike in (80, 100, 120):
print("strike", strike, round(vega(100, strike, 0.05, 0.2, 1), 3))
# strike 80 23.806
# strike 100 37.524
# strike 120 21.601
for t in (0.25, 1, 4):
print("t", t, round(vega(100, 100, 0.05, 0.2, t), 3))
# t 0.25 19.644
# t 1 37.524
# t 4 62.451 vega grows with time to expiryMedi-lo e usá-lo
A volatilidade é cotada em pontos percentuais, então as mesas de risco citam o vega por ponto: vega / 100, a variação de preço quando a volatilidade passa de 20% a 21%. Um salto de 10 pontos de volatilidade, como num susto de mercado, move a opção no dinheiro cerca de 0,375 * 10 = 3,75, quase 36% do seu preço. Como com delta e gama, dá para medir o vega de qualquer modelo perturbando: precifique com sigma + h e sigma - h e tome a diferença central. A estimativa linear erra um pouco para grandes movimentos, porque o preço também é curvo em volatilidade.
def bs_call(spot, strike, rate, sigma, t):
d_1 = d1(spot, strike, rate, sigma, t)
return spot * 0.5 * (1 + math.erf(d_1 / math.sqrt(2))) - strike * math.exp(-rate * t) * 0.5 * (1 + math.erf((d_1 - sigma * math.sqrt(t)) / math.sqrt(2)))
def numerical_vega(price_function, sigma, bump):
return (price_function(sigma + bump) - price_function(sigma - bump)) / (2 * bump)
price = lambda s: bs_call(100, 100, 0.05, s, 1)
print(round(numerical_vega(price, 0.2, 1e-4), 4)) # 37.524 the same as the formula
per_point = vega(100, 100, 0.05, 0.2, 1) / 100
print(round(per_point * 10, 3), round(price(0.30) - price(0.20), 3)) # 3.752 3.781 linear estimate vs exact, for +10 points# Vega of a put equals vega of a call: build the put price from parity and bump the volatility
put_price = lambda s: bs_call(100, 100, 0.05, s, 1) - 100 + 100 * math.exp(-0.05)
print(round(numerical_vega(put_price, 0.2, 1e-4), 4)) # 37.524 the same number as for the call- Vega =
S * pdf(d1) * sqrt(T): positivo, igual para calls e puts, máximo no dinheiro e crescente com o prazo. - Cote-o por ponto de volatilidade (
vega / 100); numericamente,(f(sigma + h) - f(sigma - h)) / (2h)vale para qualquer modelo. - Variação do preço ~
vega_por_ponto * pontos: um salto de volatilidade importa tanto quanto um movimento da ação; a volatilidade implícita é a cotação do mercado.
A seguir: teta e rô, as sensibilidades ao tempo e às taxas de juros.
Lab: o que é avaliado
- Medir a sensibilidade à volatilidade com
vega25 pts - Expressar o vega por ponto de volatilidade com
vega_per_point25 pts - Perturbar a volatilidade com
numerical_vega25 pts - Prever o efeito de um movimento de volatilidade com
price_change_from_vol25 pts