Vega

Der Input, den niemand beobachten kann

In der Black-Scholes-Formel sind Kassakurs, Strike, Zins und Zeit bekannt. Die Volatilität nicht: Sie ist die Markterwartung künftiger Bewegung und ändert sich täglich. Der Optionspreis hängt also stark von einer Zahl ab, die geschätzt werden muss, und die Sensitivität darauf, Vega, dC/dsigma, ist oft das größte Risiko eines Optionsbuchs. In Black-Scholes ist es S * pdf(d1) * sqrt(T), für Calls und Puts gleich und positiv: Mehr Volatilität macht eine Option immer wertvoller.

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%

Wo Vega am größten ist

Vega ist bei At-the-money-Optionen am größten, wo das Ergebnis am unsichersten ist und zusätzliche Volatilität am meisten ändert, und es schwindet bei tief im oder aus dem Geld liegenden Optionen (Strike 80: 23,8; 100: 37,5; 120: 21,6). Anders als Gamma wächst Vega mit der Restlaufzeit: 19,6 bei drei Monaten, 37,5 bei einem Jahr, 62,5 bei vier Jahren, weil ein längeres Leben der Volatilität mehr Zeit gibt, sich auszuwirken. Langlaufende Optionen sind daher am stärksten Volatilitätsänderungen ausgesetzt, kurzlaufende am stärksten dem Gamma.

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 expiry

Messen und nutzen

Volatilität wird in Prozentpunkten notiert, daher geben Risikoabteilungen das Vega pro Punkt an: Vega / 100, die Preisänderung, wenn die Volatilität von 20 % auf 21 % steigt. Ein Sprung um 10 Punkte, wie bei einem Marktschreck, bewegt die At-the-money-Option um etwa 0,375 * 10 = 3,75, fast 36 % ihres Preises. Wie bei Delta und Gamma lässt sich Vega für jedes Modell durch Anstoßen messen: mit sigma + h und sigma - h bewerten und die zentrale Differenz bilden. Die lineare Schätzung ist bei großen Bewegungen leicht daneben, weil der Preis auch in der Volatilität gekrümmt ist.

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): positiv, für Calls und Puts gleich, am größten am Geld und mit der Laufzeit wachsend.
• Geben Sie es pro Volatilitätspunkt an (Vega / 100); numerisch funktioniert (f(sigma + h) - f(sigma - h)) / (2h) für jedes Modell.
• Preisänderung ~ Vega_pro_Punkt * Punkte: Ein Volatilitätssprung zählt so viel wie eine Aktienbewegung; die implizite Volatilität ist die Marktnotierung.

Als Nächstes: Theta und Rho, die Sensitivitäten zu Zeit und Zinsen.

Lab: Was bewertet wird

• Mit vega die Sensitivität zur Volatilität messen25 Pkt.
• Mit vega_per_point Vega pro Volatilitätspunkt angeben25 Pkt.
• Mit numerical_vega die Volatilität anstoßen25 Pkt.
• Mit price_change_from_vol die Wirkung einer Volatilitätsbewegung vorhersagen25 Pkt.