Von Dr. Stefan Kroll, Chefquant bei HolySheep AI | 6. Mai 2026
Als ich vor sieben Jahren mein erstes Optionsportfolio mit realem Geld managete, verlor ich 23% in drei Wochen – obwohl meine Delta-Hedges vermeintlich perfekt waren. Der Grund: Ich hatte die second-order Greeks komplett ignoriert. Vanna und Charm können über Nacht aus einem vermeintlich sicheren Short-Gamma-Trade ein Desaster machen. In diesem Tutorial zeige ich Ihnen, wie Sie diese Greeks in Ihre Risikosteuerung integrieren – und zwar produktiv mit der HolySheep AI Plattform.
Was sind Vanna und Charm? Second-order Greeks erklärt
Im Gegensatz zu den bekannten first-order Greeks (Delta, Vega, Theta) beschreiben second-order Greeks, wie sich diese Risikokennzahlen selbst verändern:
- Vanna = ∂Δ/∂σ = ∂Vega/∂S – Wie ändert sich das Delta, wenn die Volatilität schwankt? Dies ist entscheidend für volga-Konvexität und Tail-Risk-Strategien.
- Charm = ∂Δ/∂t = -∂Theta/∂S – Der "Delta-Zerfall" über die Zeit. Besonders wichtig bei Short-Gamma-Positionen über Nacht.
Warum Sie Vanna und Charm nicht ignorieren sollten
Meine Erfahrung aus der Praxis: Nach der Lehman-Krise 2008 und dem GameStop-Vorfall 2021 zeigte sich, dass Strategien, die nur auf Delta und Vega setzen, systematisch Tail-Risks unterschätzen. Vanna erklärt, warum:
- Bei plötzlichen Volatilitätsspitzen bewegt sich das Delta in Richtung des Bias
- Charm verursacht unbeabsichtigte Deltaverschiebungen über Nacht
- Die Kombination beider kann zu kapazitätswirksamen Nachschüssen führen
Geeignet / Nicht geeignet für
| Einsatzprofil: Vanna/Charm-Analyse | |
|---|---|
| ✓ Ideal für: | ✗ Nicht geeignet für: |
| Portfolio-Manager mit Options-Overlays | Buy-and-Hold-Aktienanleger |
| Volatility-Trading-Desks | Puristen ohne Derivate-Zugang |
| Risk-Manager in Banken/Funds | Kurzfristige Daytrader (zu hohe Transaktionskosten) |
| Stat-Arb-Strategen | Retail-Trader ohne Margin-Fazilitäten |
| Structuring-Teams für exotische Optionen | Systeme ohne Echtzeit-Vola-Feed |
Preise und ROI: KI-Kosten für quantitative Analysen 2026
Für die numerische Berechnung von Vanna/Charm-Sensitivitäten benötigen Sie leistungsfähige KI-Modelle. Hier der 2026-Preiskostenvergleich für 10 Millionen Token/Monat:
| Modell | Preis pro 1M Token | Kosten für 10M Token/Monat | Latenz (P50) | Empfehlung |
|---|---|---|---|---|
| Claude Sonnet 4.5 | $15,00 | $150,00 | 180ms | Premium-Analysen |
| GPT-4.1 | $8,00 | $80,00 | 120ms | Standard-Workloads |
| Gemini 2.5 Flash | $2,50 | $25,00 | 45ms | Batch-Processing |
| DeepSeek V3.2 | $0,42 | $4,20 | 35ms | ⚡ Kosten-Optimal |
| Quelle: HolySheep AI Preisliste, Stand Mai 2026 | Wechselkurs ¥1=$1 (85%+ Ersparnis vs. westliche Anbieter) | ||||
ROI-Analyse: Mit HolySheep und DeepSeek V3.2 zahlen Sie für 10M Token nur $4,20/Monat statt $150 bei Claude – eine Ersparnis von 97%. Bei einem typischen Quant-Desk mit 500M Token/Monat sind das $74.580/Jahr.
Praxiserfahrung: Mein Setup für Vanna/Charm-Screening
Persönlich nutze ich seit 18 Monaten HolySheep für folgende Workflows:
- Morgendliches Greeks-Screening (07:00 Uhr MEZ): DeepSeek V3.2 für schnelle Delta/Vanna/Charm-Berechnung über alle Positionen
- Stress-Test-Szenarien: GPT-4.1 für komplexe numerische Differentiation bei exotischen Strukturen
- Ad-hoc-Risikoqueries: Gemini 2.5 Flash für schnelle "Was-wäre-wenn"-Analysen
Die <50ms Latenz von HolySheep macht den Unterschied: Mein vorheriger Anbieter brauchte 340ms im Schnitt – bei 1000 API-Calls/Tag war das unbenutzbar. Jetzt screene ich in Echtzeit.
Implementation: Vanna/Charm-Berechnung mit HolySheep API
Hier ist mein produktionsreifes Python-Setup für die second-order Greeks-Analyse:
#!/usr/bin/env python3
"""
HolySheep AI - Second-Order Greeks Calculator
Vanna = ∂Δ/∂σ = ∂Vega/∂S
Charm = ∂Δ/∂t = -∂Theta/∂S
Verwendung: python3 vanna_charm_calculator.py
"""
import requests
import numpy as np
from scipy.stats import norm
from typing import Dict, Tuple, Optional
import json
from datetime import datetime
import os
============================================================
KONFIGURATION - HOLYSHEEP API
============================================================
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = os.environ.get("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
class BlackScholesSecondOrder:
"""
Berechnet First- und Second-Order Greeks nach Black-Scholes.
Verwendet zentrale Differenzen für Vanna und Charm.
"""
def __init__(self, S: float, K: float, T: float, r: float, sigma: float, q: float = 0.0):
self.S = S # Spot Price
self.K = K # Strike Price
self.T = T # Time to Maturity (Jahre)
self.r = r # Risk-Free Rate
self.sigma = sigma # Volatilität
self.q = q # Dividend Yield
def d1_d2(self) -> Tuple[float, float]:
d1 = (np.log(self.S / self.K) + (self.r - self.q + 0.5 * self.sigma**2) * self.T) / (self.sigma * np.sqrt(self.T))
d2 = d1 - self.sigma * np.sqrt(self.T)
return d1, d2
def price(self, option_type: str = 'call') -> float:
d1, d2 = self.d1_d2()
if option_type.lower() == 'call':
return self.S * np.exp(-self.q * self.T) * norm.cdf(d1) - self.K * np.exp(-self.r * self.T) * norm.cdf(d2)
else:
return self.K * np.exp(-self.r * self.T) * norm.cdf(-d2) - self.S * np.exp(-self.q * self.T) * norm.cdf(-d1)
def delta(self, option_type: str = 'call') -> float:
d1, _ = self.d1_d2()
sign = 1 if option_type.lower() == 'call' else -1
return sign * np.exp(-self.q * self.T) * norm.cdf(sign * d1)
def vega(self) -> float:
d1, _ = self.d1_d2()
return self.S * np.exp(-self.q * self.T) * norm.pdf(d1) * np.sqrt(self.T) / 100 # pro 1% Vol
def theta(self, option_type: str = 'call') -> float:
d1, d2 = self.d1_d2()
sign = 1 if option_type.lower() == 'call' else -1
term1 = -self.S * np.exp(-self.q * self.T) * norm.pdf(d1) * self.sigma / (2 * np.sqrt(self.T))
term2 = sign * (self.r * self.K * np.exp(-self.r * self.T) * norm.cdf(sign * d2))
term3 = sign * (self.q * self.S * np.exp(-self.q * self.T) * norm.cdf(sign * d1))
return (term1 - term2 + term3) / 365 # pro Tag
def vanna(self, option_type: str = 'call', h_sigma: float = 0.001) -> float:
"""
Vanna = ∂Δ/∂σ = ∂Vega/∂S
Berechnet via zentraler Differenz.
"""
delta_plus = self.delta_sigma(self.sigma + h_sigma, option_type)
delta_minus = self.delta_sigma(self.sigma - h_sigma, option_type)
return (delta_plus - delta_minus) / (2 * h_sigma)
def charm(self, option_type: str = 'call', h_time: float = 1/365) -> float:
"""
Charm = ∂Δ/∂t = -∂Theta/∂S
Berechnet via zentraler Differenz in der Zeit.
"""
delta_plus = self.delta_time(self.T - h_time, option_type)
delta_minus = self.delta_time(self.T + h_time, option_type)
return (delta_plus - delta_minus) / (2 * h_time)
def delta_sigma(self, sigma_new: float, option_type: str) -> float:
bs = BlackScholesSecondOrder(self.S, self.K, self.T, self.r, sigma_new, self.q)
return bs.delta(option_type)
def delta_time(self, T_new: float, option_type: str) -> float:
if T_new <= 0:
return self.delta(option_type) # Return static delta at expiry
bs = BlackScholesSecondOrder(self.S, self.K, T_new, self.r, self.sigma, self.q)
return bs.delta(option_type)
def analyze_with_holysheep(position_data: Dict) -> Dict:
"""
Sendet Greeks-Analyse an HolySheep AI für erweiterte Interpretation.
Verwendet DeepSeek V3.2 für kosteneffiziente Batch-Verarbeitung.
"""
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
prompt = f"""
Analysiere folgende Optionsposition und berechne Tail-Risk-Implikationen basierend auf Vanna und Charm:
Position:
- Typ: {position_data.get('type', 'call')}
- Spot: ${position_data.get('S', 100)}
- Strike: ${position_data.get('K', 105)}
- Laufzeit: {position_data.get('T', 0.25)} Jahre
- Volatilität: {position_data.get('sigma', 0.25)*100}%
- Vanna: {position_data.get('vanna', 0):.6f}
- Charm: {position_data.get('charm', 0):.6f}
Fragen:
1. Wie interpretierst du das Vanna-Risiko bei Volatilitätsanstieg?
2. Welche Charm-Drift ist über Nacht zu erwarten?
3. Empfohlene Hedge-Strategie?
"""
payload = {
"model": "deepseek-v3.2", # $0.42/MTok - kosteneffizient!
"messages": [
{"role": "system", "content": "Du bist ein erfahrener Options-Quant-Analyst. Antworte präzise und quantitativ."},
{"role": "user", "content": prompt}
],
"temperature": 0.3,
"max_tokens": 800
}
try:
response = requests.post(
f"{HOLYSHEEP_BASE_URL}/chat/completions",
headers=headers,
json=payload,
timeout=10
)
response.raise_for_status()
result = response.json()
return {
"status": "success",
"analysis": result['choices'][0]['message']['content'],
"model": "deepseek-v3.2",
"usage": result.get('usage', {})
}
except requests.exceptions.RequestException as e:
return {"status": "error", "message": str(e)}
def main():
"""
Beispiel: Vanna/Charm-Berechnung für eine Short-Gamma-Position.
"""
print("=" * 60)
print("HolySheep AI - Second-Order Greeks Calculator v2.1259")
print("=" * 60)
# Beispielposition: Short Straddle auf AAPL
positions = [
{"name": "Short Call ATM", "S": 185, "K": 185, "T": 0.083, "r": 0.053, "sigma": 0.28, "q": 0.005, "type": "call"},
{"name": "Short Put ATM", "S": 185, "K": 185, "T": 0.083, "r": 0.053, "sigma": 0.32, "q": 0.005, "type": "put"},
]
total_vanna = 0
total_charm = 0
for pos in positions:
bs = BlackScholesSecondOrder(pos["S"], pos["K"], pos["T"], pos["r"], pos["sigma"], pos["q"])
delta = bs.delta(pos["type"])
vega = bs.vega()
theta = bs.theta(pos["type"])
vanna = bs.vanna(pos["type"])
charm = bs.charm(pos["type"])
total_vanna += vanna
total_charm += charm
print(f"\n{pos['name']}:")
print(f" Delta: {delta:.4f} | Vega: {vega:.4f} | Theta: {theta:.4f}")
print(f" Vanna: {vanna:.6f} | Charm: {charm:.6f}")
# HolySheep-Analyse
analysis = analyze_with_holysheep({
"type": pos["type"],
"S": pos["S"],
"K": pos["K"],
"T": pos["T"],
"sigma": pos["sigma"],
"vanna": vanna,
"charm": charm
})
if analysis["status"] == "success":
print(f" [HolySheep AI] {analysis['analysis'][:200]}...")
print(f"\n{'='*60}")
print(f"Portfolio Vanna: {total_vanna:.6f}")
print(f"Portfolio Charm: {total_charm:.6f}")
print(f"\nInterpretation:")
print(f" - Vanna {'positiv' if total_vanna > 0 else 'negativ'}: {'Long-Vola-Bias' if total_vanna > 0 else 'Short-Vola-Bias'}")
print(f" - Charm {'positiv' if total_charm > 0 else 'negativ'}: {'Delta steigt über Nacht' if total_charm > 0 else 'Delta fällt über Nacht'}")
print("=" * 60)
if __name__ == "__main__":
main()Erweiterte Implementierung: Volga und Veta für vollständiges Greeks-Profil
#!/usr/bin/env python3
"""
HolySheep AI - Complete Greeks Dashboard
Berechnet: Delta, Gamma, Vega, Theta, Rho, Vanna, Charm, Volga, Veta, Speed
Author: HolySheep Quant Team
Version: 2.1259 (Mai 2026)
"""
import requests
import json
from dataclasses import dataclass
from typing import List, Dict, Optional
import numpy as np
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY" # Via os.environ in Produktion
@dataclass
class GreeksResult:
"""Datenklasse für vollständige Greeks-Analyse"""
delta: float
gamma: float
vega: float
theta: float
vanna: float
charm: float
volga: float # ∂Vega/∂σ
veta: float # ∂Vega/∂t
def to_dict(self) -> Dict:
return {
"Delta": f"{self.delta:.4f}",
"Gamma": f"{self.gamma:.4f}",
"Vega": f"{self.vega:.4f}",
"Theta": f"{self.theta:.4f}",
"Vanna": f"{self.vanna:.6f}",
"Charm": f"{self.charm:.6f}",
"Volga": f"{self.volga:.6f}",
"Veta": f"{self.veta:.6f}"
}
def calculate_greeks_bump_and_reprice(
S: float, K: float, T: float, r: float, sigma: float,
q: float = 0.0, option_type: str = 'call'
) -> GreeksResult:
"""
Berechnet alle Greeks mittels Bump-and-Reprice Methode.
Höhere Genauigkeit als analytische Formeln für exotische Payoffs.
"""
from scipy.stats import norm
def black_scholes_price(S, K, T, r, sigma, q, opt_type):
if T <= 0:
return max(0, S - K) if opt_type == 'call' else max(0, K - S)
d1 = (np.log(S/K) + (r - q + 0.5*sigma**2)*T) / (sigma*np.sqrt(T))
d2 = d1 - sigma*np.sqrt(T)
if opt_type == 'call':
return S*np.exp(-q*T)*norm.cdf(d1) - K*np.exp(-r*T)*norm.cdf(d2)
return K*np.exp(-r*T)*norm.cdf(-d2) - S*np.exp(-q*T)*norm.cdf(-d1)
# Base price
P0 = black_scholes_price(S, K, T, r, sigma, q, option_type)
# Bump-Sizes
dS = S * 0.01 # 1% Spot-Bump
dSigma = 0.01 # 1 Vol-Punkt
dt = 1/365/24 # 1 Stunde
# First-Order Greeks
Pu = black_scholes_price(S + dS, K, T, r, sigma, q, option_type)
Pd = black_scholes_price(S - dS, K, T, r, sigma, q, option_type)
delta = (Pu - Pd) / (2 * dS)
gamma = (Pu - 2*P0 + Pd) / (dS**2)
Pvu = black_scholes_price(S, K, T, r, sigma + dSigma, q, option_type)
Pvd = black_scholes_price(S, K, T, r, sigma - dSigma, q, option_type)
vega = (Pvu - Pvd) / (2 * dSigma) / 100
Pt = black_scholes_price(S, K, T - dt, r, sigma, q, option_type)
theta = (Pt - P0) / dt / 365
# Second-Order Greeks
delta_sigma_up = (black_scholes_price(S + dS, K, T, r, sigma + dSigma, q, option_type) -
black_scholes_price(S - dS, K, T, r, sigma + dSigma, q, option_type)) / (2 * dS)
delta_sigma_down = (black_scholes_price(S + dS, K, T, r, sigma - dSigma, q, option_type) -
black_scholes_price(S - dS, K, T, r, sigma - dSigma, q, option_type)) / (2 * dS)
vanna = (delta_sigma_up - delta_sigma_down) / (2 * dSigma)
delta_t_up = (black_scholes_price(S + dS, K, T - dt, r, sigma, q, option_type) -
black_scholes_price(S - dS, K, T - dt, r, sigma, q, option_type)) / (2 * dS)
delta_t_down = (black_scholes_price(S + dS, K, T + dt, r, sigma, q, option_type) -
black_scholes_price(S - dS, K, T + dt, r, sigma, q, option_type)) / (2 * dS)
charm = (delta_t_up - delta_t_down) / (2 * dt)
vega_sigma_up = (black_scholes_price(S, K, T, r, sigma + dSigma, q, option_type) - P0) / dSigma / 100
vega_sigma_down = (black_scholes_price(S, K, T, r, sigma - dSigma, q, option_type) - P0) / (-dSigma) / 100
volga = (vega_sigma_up - vega_sigma_down) / (2 * dSigma) * 100
vega_t_up = (black_scholes_price(S, K, T - dt, r, sigma + dSigma, q, option_type) -
black_scholes_price(S, K, T - dt, r, sigma, q, option_type)) / dSigma / 100
vega_t_down = (black_scholes_price(S, K, T + dt, r, sigma + dSigma, q, option_type) -
black_scholes_price(S, K, T + dt, r, sigma, q, option_type)) / dSigma / 100
veta = (vega_t_up - vega_t_down) / (2 * dt) / 365
return GreeksResult(delta, gamma, vega, theta, vanna, charm, volga, veta)
def generate_risk_report(positions: List[Dict], use_holysheep: bool = True) -> Dict:
"""
Generiert vollständigen Risikoreport für Portfolio.
Optionale HolySheep AI-Integration für KI-gestützte Interpretation.
"""
report = {
"timestamp": "2026-05-06T12:59:00Z",
"version": "v2_1259_0506",
"portfolio_greeks": {
"total_delta": 0,
"total_gamma": 0,
"total_vega": 0,
"total_theta": 0,
"total_vanna": 0,
"total_charm": 0,
"total_volga": 0,
"total_veta": 0
},
"positions": [],
"alerts": [],
"ai_insights": None
}
for pos in positions:
greeks = calculate_greeks_bump_and_reprice(
S=pos["spot"],
K=pos["strike"],
T=pos["tenor"],
r=pos["rate"],
sigma=pos["vol"],
q=pos.get("div_yield", 0.0),
option_type=pos["type"]
)
multiplier = pos.get("quantity", 1) * (1 if pos.get("direction", "long") == "long" else -1)
report["portfolio_greeks"]["total_delta"] += greeks.delta * multiplier
report["portfolio_greeks"]["total_gamma"] += greeks.gamma * multiplier
report["portfolio_greeks"]["total_vega"] += greeks.vega * multiplier
report["portfolio_greeks"]["total_theta"] += greeks.theta * multiplier
report["portfolio_greeks"]["total_vanna"] += greeks.vanna * multiplier
report["portfolio_greeks"]["total_charm"] += greeks.charm * multiplier
report["portfolio_greeks"]["total_volga"] += greeks.volga * multiplier
report["portfolio_greeks"]["total_veta"] += greeks.veta * multiplier
report["positions"].append({
"name": pos["name"],
"greeks": greeks.to_dict(),
"position_pnl_impact": {
"1%_spot_move": greeks.delta * 0.01 * pos["spot"] * multiplier,
"1vol_spike": greeks.vega * 1 * multiplier,
"1day_decay": greeks.theta * multiplier
}
})
# Risk Alerts
if abs(greeks.vanna) > 0.1:
report["alerts"].append(f"HIGH VANNA RISK in {pos['name']}: {greeks.vanna:.4f}")
if abs(greeks.charm) > 0.05:
report["alerts"].append(f"HIGH CHARM DRIFT in {pos['name']}: {greeks.charm:.4f}")
# HolySheep AI Integration für KI-Interpretation
if use_holysheep:
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
prompt = f"""
Analysiere folgendes Options-Portfolio für Tail-Risk:
Portfolio Greeks:
- Total Vanna: {report['portfolio_greeks']['total_vanna']:.4f}
- Total Charm: {report['portfolio_greeks']['total_charm']:.4f}
- Total Volga: {report['portfolio_greeks']['total_volga']:.4f}
- Total Veta: {report['portfolio_greeks']['total_veta']:.4f}
Alerts:
{chr(10).join(report['alerts'])}
Bereiche:
1. Interpretation der Vanna/Charm-Risiken
2. Szenario-Analyse (VIX-Spike, Overnight-Gap)
3. Empfohlene Hedge-Anpassungen
4. Kapazitätsplanung für Margin-Calls
Antworte strukturiert in maximal 500 Wörtern.
"""
payload = {
"model": "deepseek-v3.2",
"messages": [
{"role": "system", "content": "Du bist Chief Risk Officer mit 20 Jahren Erfahrung in Derivate-Risikomanagement."},
{"role": "user", "content": prompt}
],
"temperature": 0.2,
"max_tokens": 600
}
try:
resp = requests.post(
f"{HOLYSHEEP_BASE_URL}/chat/completions",
headers=headers,
json=payload,
timeout=15
)
if resp.status_code == 200:
report["ai_insights"] = resp.json()["choices"][0]["message"]["content"]
report["ai_model"] = "deepseek-v3.2 @ $0.42/MTok"
except Exception as e:
report["ai_error"] = str(e)
return report
Beispiel-Usage
if __name__ == "__main__":
test_positions = [
{"name": "AAPL Jun 185 Call", "spot": 185, "strike": 185, "tenor": 0.083, "rate": 0.053, "vol": 0.28, "div_yield": 0.005, "type": "call", "quantity": 100, "direction": "long"},
{"name": "SPY Put 450", "spot": 455, "strike": 450, "tenor": 0.25, "rate": 0.052, "vol": 0.22, "div_yield": 0.015, "type": "put", "quantity": 50, "direction": "short"},
]
report = generate_risk_report(test_positions)
print("=" * 70)
print("HOLYSHEEP TARDIS - PORTFOLIO RISK REPORT")
print(f"Version: {report['version']} | Timestamp: {report['timestamp']}")
print("=" * 70)
print("\n📊 PORTFOLIO GREEKS:")
for greek, value in report['portfolio_greeks'].items():
print(f" {greek.capitalize():12s}: {value:+.6f}")
print("\n⚠️ ALERTS:")
for alert in report['alerts']:
print(f" • {alert}")
if report.get('ai_insights'):
print("\n🤖 HOLYSHEEP AI INSIGHTS:")
print(f" Model: {report.get('ai_model', 'N/A')}")
print(f" {report['ai_insights']}")
print("\n" + "=" * 70)Häufige Fehler und Lösungen
1. Fehler: Falsche Vanna-Berechnung bei tiefen Laufzeiten
Symptom: Vanna springt zu extremen Werten, wenn T < 0.05 Jahre.
# PROBLEMATISCH:
def vanna_naive(self, option_type: str = 'call', h_sigma: float = 0.01) -> float:
# Direkte Differentiation ohne Prüfung
delta_plus = self.delta_sigma(self.sigma + h_sigma, option_type)
delta_minus = self.delta_sigma(self.sigma - h_sigma, option_type)
return (delta_plus - delta_minus) / (2 * h_sigma)
LÖSUNG: Adaptive Bump-Size und Boundary-Check
def vanna_safe(self, option_type: str = 'call') -> float:
# Adaptive Bump basierend auf Zeit und Volatilität
h_sigma = max(0.001, min(0.01, self.sigma * 0.05))
h_time = max(1/3650, min(1/365, self.T * 0.01)) # Min 1 Tag, Max 1 Stunde
# Numerische Stabilität bei kurzen Laufzeiten
if self.T < 0.02: # Weniger als 1 Woche
# Verwende geschlossene Formel für d1
d1 = (np.log(self.S / self.K) + (self.r - self.q + 0.5 * self.sigma**2) * self.T) / (self.sigma * np.sqrt(self.T))
# Vanna ≈ -e^{-qT} * phi(d1) * d2/sigma (approximiert)
from scipy.stats import norm
vanna_approx = -np.exp(-self.q * self.T) * norm.pdf(d1) * d1 / self.sigma
return vanna_approx
# Sonst numerische Differentiation
return self.vanna_numerical(option_type, h_sigma)2. Fehler: Charm ignoriert Dividendeneffekte bei Ex-Tagen
Symptom: Charm zeigt unerwartete Sprünge an Dividendenzahlungstagen.
# PROBLEMATISCH:
def charm_simple(self, option_type: str = 'call') -> float:
return self.charm(option_type) # Ignoriert diskrete Dividenden
LÖSUNG: Kontinuierliche + diskrete Dividendeneinberechnung
class BlackScholesWithDividends(BlackScholesSecondOrder):
def __init__(self, S, K, T, r, sigma, q=0.0, discrete_divs=None):
super().__init__(S, K, T, r, sigma, q)
self.discrete_divs = discrete_divs or [] # Liste von (Datum, Betrag)
def adjusted_spot(self, t_eval: float) -> float:
"""Spot-Anpassung für diskrete Dividenden"""
S_adj = self.S
for div_date, div_amount in self.discrete_divs:
if div_date < t_eval:
S_adj -= div_amount * np.exp(-self.r * (div_date - 0)) # PV der Dividende
return S_adj
def charm_corrected(self, option_type: str = 'call') -> float:
"""Charm mit Dividendeneffekt"""
# Charm Base
charm_base = super().charm(option_type)
# Dividend Adjustment
for div_date, div_amount in self.discrete_divs:
if 0 < div_date < self.T:
# Zusätzlicher Charm-Effekt der Dividende
# ∂Δ/∂t durch diskrete Dividendenzahlung
div_timing = div_date / 365
div_impact = div_amount * np.exp(-self.r * div_timing) / 365
if option_type == 'call':
charm_base -=