Theta und Rho

Zwei weitere Arten, wie sich der Preis bewegt

Delta, Gamma und Vega decken die Aktie und ihre Volatilität ab. Zwei Eingaben der Black-Scholes-Formel bleiben: die Restlaufzeit und der Zins. Theta ist die Wertänderung einer Option mit der Zeit (das t der Formel schrumpft jeden Tag), Rho die Änderung bei Zinsbewegungen. Theta spürt ein Händler täglich: Eine Long-Option ist ein Wertverzehr-Asset, und die täglich verlorene Prämie ist der Preis für die gehaltene Konvexität.

import math

def norm_cdf(x):
    return 0.5 * (1 + math.erf(x / math.sqrt(2)))

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 d2(spot, strike, rate, sigma, t):
    return d1(spot, strike, rate, sigma, t) - sigma * math.sqrt(t)

def call_theta(spot, strike, rate, sigma, t):
    decay = -spot * norm_pdf(d1(spot, strike, rate, sigma, t)) * sigma / (2 * math.sqrt(t))
    carry = -rate * strike * math.exp(-rate * t) * norm_cdf(d2(spot, strike, rate, sigma, t))
    return decay + carry

theta = call_theta(100, 100, 0.05, 0.2, 1)
print(round(theta, 4))             # -6.414   per year
print(round(theta / 365, 4))       # -0.0176  per calendar day

Theta: warum die Zeit schmerzt

Der erste Term von Theta, -S * pdf(d1) * sigma / (2 * sqrt(T)), ist der Verfall des *Optionswerts*: Mit weniger Zeit sinkt die Chance auf eine große Bewegung. Der zweite, -r * K * exp(-rT) * N(d2), ist der Zins auf den Strike, den man noch nicht zahlen muss und den der Call-Käufer verdient. Beide sind für einen Call negativ, also auch Theta, und der Verlust ist nicht gleichmäßig: Er beschleunigt sich zum Verfall hin, am stärksten bei Optionen am Geld. Man gibt ihn pro Kalendertag an, Theta / 365.

# Theta per day for the same option as expiry approaches: the decay speeds up
import math

def norm_cdf(x):
    return 0.5 * (1 + math.erf(x / math.sqrt(2)))

def norm_pdf(x):
    return math.exp(-0.5 * x * x) / math.sqrt(2 * math.pi)

def call_theta(spot, strike, rate, sigma, t):
    d_1 = (math.log(spot / strike) + (rate + 0.5 * sigma ** 2) * t) / (sigma * math.sqrt(t))
    d_2 = d_1 - sigma * math.sqrt(t)
    return -spot * norm_pdf(d_1) * sigma / (2 * math.sqrt(t)) - rate * strike * math.exp(-rate * t) * norm_cdf(d_2)

for days in (360, 90, 30, 7):
    per_day = call_theta(100, 100, 0.05, 0.2, days / 365) / 365
    print(days, "days left:", round(per_day, 4))     # 360: -0.0177, 90: -0.0288, 30: -0.045, 7: -0.0858

Rho: der Zins

Rho ist K * T * exp(-rT) * N(d2): positiv für einen Call, weil ein höherer Zins den Barwert des zu zahlenden Strikes senkt. Ein Put hat das umgekehrte Vorzeichen. Es ist der kleinste Griechen-Wert bei kurzlaufenden Optionen und wichtig bei langen (LEAPS, langlaufende Optionsscheine). Man gibt es pro Prozentpunkt Zins an, Rho / 100, wie Vega pro Volatilitätspunkt.

# Rho of the one-year call at several rates: it grows with the rate and with the time left
import math

def norm_cdf(x):
    return 0.5 * (1 + math.erf(x / math.sqrt(2)))

def call_rho(spot, strike, rate, sigma, t):
    d_1 = (math.log(spot / strike) + (rate + 0.5 * sigma ** 2) * t) / (sigma * math.sqrt(t))
    return strike * t * math.exp(-rate * t) * norm_cdf(d_1 - sigma * math.sqrt(t))

for rate in (0.0, 0.05, 0.10):
    print("rate", rate, "rho per point:", round(call_rho(100, 100, rate, 0.2, 1) / 100, 4))   # 0.0: 0.4602, 0.05: 0.5323, 0.1: 0.5931
print("two years, 5%:", round(call_rho(100, 100, 0.05, 0.2, 2) / 100, 4))                  # 1.0568

# Check theta and rho by bumping the inputs: they are slopes of the price
import math

def norm_cdf(x):
    return 0.5 * (1 + math.erf(x / math.sqrt(2)))

def bs_call(spot, strike, rate, sigma, t):
    d_1 = (math.log(spot / strike) + (rate + 0.5 * sigma ** 2) * t) / (sigma * math.sqrt(t))
    return spot * norm_cdf(d_1) - strike * math.exp(-rate * t) * norm_cdf(d_1 - sigma * math.sqrt(t))

h = 1e-5
theta = -(bs_call(100, 100, 0.05, 0.2, 1 + h) - bs_call(100, 100, 0.05, 0.2, 1 - h)) / (2 * h)
rho = (bs_call(100, 100, 0.05 + h, 0.2, 1) - bs_call(100, 100, 0.05 - h, 0.2, 1)) / (2 * h)
print(round(theta, 4), round(rho, 4))                    # -6.414 53.2325

• Theta ist der Wertverlust mit der Zeit: negativ für einen Long-Call, schneller nahe Verfall und am Geld; Angabe als Theta / 365 pro Tag.
• Rho ist die Zinssensitivität: positiv für Calls, negativ für Puts, am größten bei langen Laufzeiten; Angabe als Rho / 100 pro Punkt.
• Beide sind Steigungen des Preises, ein kleiner Schubs von t oder rate prüft jede Formel.

Als Nächstes: die implizite Volatilität, die Formel rückwärts nutzen, um die Marktvolatilität aus einem Optionspreis zu lesen.

Lab: Was bewertet wird

• Mit call_theta den Zeitablauf bewerten25 Pkt.
• Mit theta_per_day den täglichen Verfall angeben25 Pkt.
• Mit call_rho die Zinssensitivität messen25 Pkt.
• Mit rho_per_point Rho pro Prozentpunkt angeben25 Pkt.