Die „Griechen“ in Black-Scholes automatisieren: Fortgeschrittenes Scalping und Mikrostrukturhandel

Inhaltsverzeichnis

1. Einführung
2. Überblick über die Automatisierung
3. Die ersten Schritte
4. Ergebnisse der Backtests
5. Schlussfolgerung

Einführung

Im vorangegangenen Artikel haben wir das Fundament gelegt, indem wir die Kernmechanik der „Griechen“ Delta und Gamma im Black-Scholes-Modell erläutert haben – wie Delta die Richtungssensitivität erfasst und wie Gamma die Änderungsrate von Delta misst. Wir haben gezeigt, wie diese Parameter, die ursprünglich für die Absicherung von Optionen entwickelt wurden, in den Kontext des Handels und der Volatilität übertragen werden können und so die Voraussetzungen für algorithmische Anwendungen schaffen.

Wir gehen über die theoretische Darstellung hinaus und kommen zur Umsetzung. Darüber hinaus werden wir uns mit der systematischen Berechnung der „Griechen“ in einer algorithmischen Umgebung befassen, sie in Ihr MetaTrader 5 Expert Advisor Framework integrieren und sie als Echtzeit-Trigger für Scalping- und Mikrostruktur-Strategien verwenden. Wir werden untersuchen, wie Delta und Gamma nicht nur zur Absicherung, sondern auch als leistungsstarke Eingangssignale in Hochfrequenzkontexten verwendet werden können: zur Identifizierung ultrakurzfristiger Liquiditätsverschiebungen und zur Automatisierung präziser Ein- und Ausstiege in sich schnell bewegenden Märkten.

Überblick über die Automatisierung

Unser Hauptziel ist es, ein automatisiertes Handelssystem zu entwickeln, das Optionspositionen durch kontinuierliches Delta-Hedging und strategisches Gamma-Scalping dynamisch verwaltet. Das Kernkonzept besteht darin, ein deltaneutrales Portfolio zu halten und gleichzeitig von gamma-bedingten Kursbewegungen zu profitieren. Da sich die Delta-Werte von Optionen mit der Entwicklung des Basiswertpreises ändern (ein Phänomen, das durch Gamma gemessen wird), benötigen wir ein automatisiertes System, das diese griechischen Bestimmungsgrößen kontinuierlich überwachen und Handelsgeschäfte zur Neugewichtung des Portfolios ausführen kann. Dieser Ansatz zielt darauf ab, von der Volatilität des Basiswerts und nicht von dessen direktionaler Bewegung zu profitieren. So entsteht eine marktneutrale Strategie, die Renditen durch häufige, kleine Anpassungen und nicht durch Wetten auf die Kursrichtung erzielt.

Der Automatisierungsprozess umfasst die Implementierung von Echtzeitberechnungen der griechischen Bestimmungsgrößen des Black-Scholes-Modells, insbesondere Delta und Gamma, auf der Grundlage des aktuellen Marktpreises von EU50, des festgelegten Ausübungspreises und der Zeit bis zum Verfall. Das System verfolgt ständig die gesamte Delta-Exposition des Portfolios, die das Delta aus unseren Optionspositionen mit etwaigen Absicherungspositionen im Basiswert kombiniert. Wenn das Netto-Delta des Portfolios über einen bestimmten Schwellenwert hinaus von Null abweicht, führt das System automatisch Handelsgeschäfte mit dem Basiswert EU50 aus, um die Delta-Neutralität wiederherzustellen. Gleichzeitig werden wir eine Gamma-Scalping-Logik implementieren, die Perioden mit hoher Gamma-Sensitivität identifiziert – wenn das Delta der Option am stärksten auf Preisänderungen reagiert – um strategische Handelsgeschäfte auszuführen, die von diesen erhöhten Sensitivitätsperioden profitieren.

Um einen robusten Betrieb zu gewährleisten, wird das automatisierte System mehrere Ebenen des Risikomanagements umfassen, darunter Kontrollen der Positionsgröße, Stop-Loss-Mechanismen und eine dynamische Anpassung der Absicherungshäufigkeit auf der Grundlage der Marktbedingungen. Das System berücksichtigt den Zeitverfall, wenn der Verfallstermin näher rückt, und passt seine Strategie an die beschleunigenden Effekte von Theta an. Durch die Automatisierung dieses komplexen Zusammenspiels zwischen Delta-Hedging und Gamma-Scalping schaffen wir ein ausgeklügeltes Optionshandelssystem, das rund um die Uhr arbeiten kann und mit einer Präzision und Disziplin auf Marktbewegungen reagiert, die manuell nur schwer aufrechtzuerhalten wäre, und das letztlich darauf abzielt, durch Volatilitätserfassung und dynamisches Positionsmanagement beständige Gewinne zu erzielen.

Die ersten Schritte

//+------------------------------------------------------------------+
//|                                               AutoGammaDelta.mq5 |
//|                        GIT under Copyright 2025, MetaQuotes Ltd. |
//|                     https://www.mql5.com/en/users/johnhlomohang/ |
//+------------------------------------------------------------------+
#property copyright "GIT under Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com/en/users/johnhlomohang/"
#property version   "1.00"
#include <Trade\Trade.mqh>
#include <Math\Stat\Normal.mqh>

//--- Input Parameters
input double   StrikePrice     = 5000.0;    // Option strike price
input double   Volatility      = 0.1691;    // Annual volatility (16.91%)
input double   RiskFreeRate    = 0.04;      // Risk-free interest rate
input double   DividendYield   = 0.02;      // Dividend yield
input double   OptionPosition  = 1.0;       // Option contract size (positive long, negative short)
input double   DeltaThreshold  = 0.10;      // Delta hedge threshold
input double   GammaThreshold  = 0.0001;    // Gamma hedge threshold  
input double   LotSize         = 0.1;       // Trading lot size for underlying
input int      StopLoss        = 50;        // Hedge Stop Loss (points)
input int      TakeProfit      = 30;        // Hedge Take Profit (points)
input int      HedgeFrequency  = 1;         // Hedge check frequency (minutes)
input bool     EnableTrading   = true;      // Enable actual trading

//--- Global Variables
CTrade         trade;
double         currentDelta, currentGamma;
double         portfolioDelta, targetDelta;
datetime       lastHedgeTime;
int            currentHedgeFrequency;

Dieser Codeblock richtet die vollständige Parameter- und Infrastrukturebene ein, die für die Automatisierung der Delta-Gamma-Absicherung in einer MQL5-Umgebung erforderlich ist. Die ersten beiden enthalten Dateien für die Handelsklasse (CTrade) und die statistischen Funktionen, die für die Berechnung der kumulativen Normalverteilung erforderlich sind – eine wesentliche Komponente für die Berechnung der Black-Scholes-Grenzen. Die Eingabeparameter definieren alle optionsbezogenen Variablen (Ausübungspreis, Volatilität, Zinssatz, Dividendenrendite und Optionsposition) sowie die Schwellenwerte für Delta- und Gamma-Anpassungen, die bestimmen, wann das System die Absicherung neu ausbalancieren soll. Zusätzliche Handelsparameter wie Losgröße, Stop-Loss, Take-Profit, Hedge-Häufigkeit und ein Schalter zum Aktivieren oder Deaktivieren des Live-Handels geben dem Nutzer die volle Kontrolle darüber, wie aggressiv oder konservativ die Hedging-Logik in den Markt eingreifen soll.

Die globalen Variablen bereiten den EA auf die Echtzeitberechnung und -ausführung vor. Das Handelsobjekt CTrade wickelt alle Kauf- und Verkaufsoperationen für das zugrunde liegende Instrument ab, das für die Absicherung verwendet wird. currentDelta und currentGamma speichern die zuletzt berechneten „Griechen“, während portfolioDelta und targetDelta dabei helfen, zu verfolgen, wie weit das aktuelle Engagement vom gewünschten Absicherungsstatus entfernt ist (in der Regel nahe Null für delta-neutrale Strategien). lastHedgeTime und currentHedgeFrequency werden verwendet, um zu regulieren, wie oft das System die Absicherung bewertet, um sicherzustellen, dass der Algorithmus nicht zu viel handelt und dennoch schnell genug auf Marktveränderungen reagiert. Zusammen bilden diese Variablen das Rückgrat einer automatisierten Black-Scholes-Hedging-Maschine, die das Risiko kontinuierlich überwacht und Mikroanpassungen in Echtzeit vornimmt.

//+------------------------------------------------------------------+
//| Black-Scholes Greeks Calculator                                  |
//+------------------------------------------------------------------+
double NormalCDF(double x)
{
   double a1=0.254829592, a2=-0.284496736, a3=1.421413741;
   double a4=-1.453152027, a5=1.061405429, p=0.3275911;
   int sign = 1;
   if(x < 0) { sign = -1; x = -x; }
   double t = 1.0/(1.0 + p*x);
   double y = 1.0 - (((((a5*t + a4)*t) + a3)*t + a2)*t + a1)*t*MathExp(-x*x);
   return 0.5*(1.0 + sign*y);
}

double NormalPDF(double x)
{
   return MathExp(-0.5*x*x)/MathSqrt(2.0*M_PI);
}

void BS_d1d2(double S, double K, double sigma, double T, double r, double q, double &d1, double &d2)
{
   if(T <= 0 || sigma <= 0) { d1 = d2 = 0.0; return; }
   double sqt = sigma * MathSqrt(T);
   d1 = (MathLog(S/K) + (r - q + 0.5*sigma*sigma)*T) / sqt;
   d2 = d1 - sqt;
}

double CalculateDelta(double S, double K, double sigma, double T, double r, double q)
{
   if(T <= 0) return (S > K) ? 1.0 : 0.0;
   double d1, d2;
   BS_d1d2(S, K, sigma, T, r, q, d1, d2);
   return MathExp(-q*T) * NormalCDF(d1);
}

double CalculateGamma(double S, double K, double sigma, double T, double r, double q)
{
   if(T <= 0 || sigma <= 0) return 0.0;
   double d1, d2;
   BS_d1d2(S, K, sigma, T, r, q, d1, d2);
   double pdf = NormalPDF(d1);
   return (pdf * MathExp(-q*T)) / (S * sigma * MathSqrt(T));
}

//+------------------------------------------------------------------+
//| Time to Expiry Calculator                                        |
//+------------------------------------------------------------------+
double TimeToExpiry()
{
   datetime expiry = D'2025.12.31 23:59:59';
   datetime current = TimeCurrent();
   double days = (expiry - current) / (60.0 * 60.0 * 24.0);
   return MathMax(days / 365.0, 0.0);
}

Im vorherigen Artikel bildeten diese Funktionen das mathematische Rückgrat unseres Delta-Gamma-Automatisierungsrahmens, indem sie die wesentlichen Komponenten des Black-Scholes-Modells direkt in MQL5 implementierten. Wir begannen mit der Konstruktion von NormalCDF und NormalPDF, die eine Annäherung an die kumulativen und Wahrscheinlichkeitsdichtefunktionen der Standardnormalverteilung darstellen. Diese Funktionen sind für jede Berechnung der „Griechen“ im Black-Scholes-System erforderlich, da sich das Modell im Wesentlichen darauf stützt, wie wahrscheinlich Preisbewegungen im Verhältnis zur Normalkurve sind. Die Implementierung verwendet eine schnelle numerische Annäherung, die für Echtzeit-Handelsumgebungen geeignet ist, in denen Leistung wichtig ist.

Auf der Grundlage dieser statistischen Werkzeuge haben wir dann die Funktion BS_d1d2 definiert, die die in den „Griechen“ verwendeten Kerneingaben d1 und d2 berechnet. Diese Werte spiegeln den standardisierten Abstand zwischen dem aktuellen Kurs und dem Ausübungspreis wider, bereinigt um Volatilität, Zeit, Zinssatz und Dividendenrendite. Da d1 und d2 verfügbar sind, haben wir CalculateDelta und CalculateGamma implementiert, die das Herzstück des Optionssensitivitätsmodells bilden. Delta misst die Rate, mit der sich der Optionspreis im Verhältnis zum Basiswert ändert, während Gamma die Krümmung misst, d. h. wie schnell Delta selbst auf Preisänderungen reagiert. Beide Funktionen beinhalten eine Diskontierung für Dividenden und stützen sich direkt auf die zuvor erstellten Normalverteilungsfunktionen.

Schließlich bietet die Funktion TimeToExpiry eine saubere, automatisierte Möglichkeit, die verbleibende Optionslaufzeit in Jahren zu verfolgen, die für alle Optionspreise und „Griechen“ entscheidend ist. Durch die Berechnung der Differenz zwischen der aktuellen Serverzeit und einem festen Verfallsdatum und die Umrechnung in einen Jahresbruchteil ermöglicht dieses Hilfsprogramm dem EA, Delta und Gamma kontinuierlich zu aktualisieren, während die Echtzeit voranschreitet. Diese Funktionen ermöglichten es uns, die theoretische Black-Scholes-Mathematik mit praktischer, algorithmischer Echtzeit-Handelslogik zu verbinden – und damit die Grundlage für das automatische Scalp-Hedging-System zu schaffen.

//+------------------------------------------------------------------+
//| Position Management Functions                                    |
//+------------------------------------------------------------------+
double GetUnderlyingPosition()
{
   double position = 0.0;
   int total = PositionsTotal();
   
   for(int i = 0; i < total; i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(PositionGetString(POSITION_SYMBOL) == _Symbol)
      {
         long type = PositionGetInteger(POSITION_TYPE);
         double volume = PositionGetDouble(POSITION_VOLUME);
         
         if(type == POSITION_TYPE_BUY)
            position += volume;
         else if(type == POSITION_TYPE_SELL)
            position -= volume;
      }
   }
   return position;
}

double CalculatePortfolioDelta()
{
   double underlyingPos = GetUnderlyingPosition();
   double optionDelta = currentDelta * OptionPosition;
   return underlyingPos + optionDelta;
}

Diese Positionsmanagementfunktionen übernehmen die wichtige Aufgabe, das aktuelle Engagement des Händlers im Basiswert zu überwachen und es mit dem Delta der Option zu kombinieren, um das Gesamtportfolio-Delta zu berechnen. GetUnderlyingPosition() durchläuft alle offenen Positionen des Kontos und filtert nur diejenigen heraus, die dem aktuellen Symbol entsprechen. Anschließend wird das Nettorisiko ermittelt, indem das Volumen der Kaufgeschäfte addiert und das Volumen der Verkaufsgeschäfte subtrahiert wird. Dies vermittelt ein klares Bild davon, wie viel des zugrunde liegenden Vermögenswerts der Händler derzeit hält, ausgedrückt als positive (Netto-Kaufposition), negative (Netto-Verkaufsposition) oder keine Position („flat“).

Die Funktion CalculatePortfolioDelta() erweitert dies, indem sie die Empfindlichkeit der Option gegenüber Preisänderungen einbezieht. Es multipliziert das aktuelle Options-Delta mit der Größe der Optionsposition, um das „optionsseitige Delta“ zu berechnen, und addiert es dann zu der von GetUnderlyingPosition() zurückgegebenen Netto-Basiswertposition. Das Ergebnis ist ein vollständiger Portfolio-Delta-Wert, der sowohl die Options- als auch die Hedge-Legs zusammen widerspiegelt. Diese Messung ist für deltaneutrale oder deltazentrierte Strategien unerlässlich, da das System anhand von Abweichungen vom gewünschten Deltazustand entscheiden kann, wann eine Anpassung der Absicherung erforderlich ist.

//+------------------------------------------------------------------+
//| Gamma Scalping Logic                                             |
//+------------------------------------------------------------------+
int CalculateDynamicFrequency()
{
   // Adjust frequency based on gamma levels
   if(currentGamma > GammaThreshold * 2)
      return 1;  // High gamma - check every minute
   else if(currentGamma > GammaThreshold)
      return HedgeFrequency; // Medium gamma - use base frequency
   else
      return 5;  // Low gamma - check every 5 minutes
}

//+------------------------------------------------------------------+
//| Execute trade with risk parameters                               |
//+------------------------------------------------------------------+
void ExecuteTrade(ENUM_ORDER_TYPE tradeType, string symbol)
{
   if(!EnableTrading) 
   {
      Print("DEMO: ", EnumToString(tradeType), " ", LotSize, " lots");
      return;
   }
   
   double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
   double price = (tradeType == ORDER_TYPE_BUY) ? SymbolInfoDouble(symbol, SYMBOL_ASK) :
                                                SymbolInfoDouble(symbol, SYMBOL_BID);

   double sl_distance = StopLoss * point * 10; // Convert points to price
   double tp_distance = TakeProfit * point * 10;
   
   double sl = (tradeType == ORDER_TYPE_BUY) ? price - sl_distance : price + sl_distance;
   double tp = (tradeType == ORDER_TYPE_BUY) ? price + tp_distance : price - tp_distance;

   if(trade.PositionOpen(symbol, tradeType, LotSize, price, sl, tp, "GammaDelta Hedge"))
   {
      Print("TRADE EXECUTED: ", EnumToString(tradeType), 
            " Lots: ", LotSize, 
            " Price: ", price,
            " SL: ", sl, 
            " TP: ", tp);
   }
   else
   {
      Print("TRADE FAILED: ", EnumToString(tradeType), 
            " Error: ", GetLastError());
   }
}

//+------------------------------------------------------------------+
//| Gamma-Based Trading Strategy                                     |
//+------------------------------------------------------------------+
void ExecuteGammaStrategy()
{
   double S = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   
   // Strategy 1: Gamma Scalping - Trade when gamma indicates high sensitivity
   if(currentGamma > GammaThreshold * 1.5)
   {
      Print("High Gamma detected: ", currentGamma, " - Gamma scalping opportunity");
      
      // If gamma is high and we're near the strike, consider directional trades
      if(MathAbs(S - StrikePrice) < (StrikePrice * 0.02)) // Within 2% of strike
      {
         if(currentDelta > 0.6) 
         {
            Print("Gamma Scalp: BUY signal (High Delta: ", currentDelta, ")");
            ExecuteTrade(ORDER_TYPE_BUY, _Symbol);
         }
         else if(currentDelta < 0.4)
         {
            Print("Gamma Scalp: SELL signal (Low Delta: ", currentDelta, ")");
            ExecuteTrade(ORDER_TYPE_SELL, _Symbol);
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Delta Hedging Engine                                             |
//+------------------------------------------------------------------+
void ExecuteDeltaHedge()
{
   portfolioDelta = CalculatePortfolioDelta();
   targetDelta = 0.0; // Target delta-neutral
  
   double deltaDeviation = MathAbs(portfolioDelta - targetDelta);
   
   Print("Delta Check - Portfolio: ", portfolioDelta, " Deviation: ", deltaDeviation);
   
   if(deltaDeviation > DeltaThreshold)
   {
      // Determine trade direction
      ENUM_ORDER_TYPE orderType;
      if(portfolioDelta > targetDelta)
      {
         orderType = ORDER_TYPE_SELL; // Sell to reduce positive delta
         Print("DELTA HEDGE: SELL to reduce positive delta ", portfolioDelta);
      }
      else
      {
         orderType = ORDER_TYPE_BUY;  // Buy to reduce negative delta
         Print("DELTA HEDGE: BUY to reduce negative delta ", portfolioDelta);
      }
      
      ExecuteTrade(orderType, _Symbol);
   }
}

//+------------------------------------------------------------------+
//| Combined Gamma & Delta Strategy                                  |
//+------------------------------------------------------------------+
void ExecuteCombinedStrategy()
{
   double S = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double T = TimeToExpiry();
   
   // Update Greeks
   currentDelta = CalculateDelta(S, StrikePrice, Volatility, T, RiskFreeRate, DividendYield);
   currentGamma = CalculateGamma(S, StrikePrice, Volatility, T, RiskFreeRate, DividendYield);
   
   Print("Strategy Analysis - Price: ", S, " Delta: ", currentDelta, " Gamma: ", currentGamma);
   
   // 1. Execute Delta Hedging (Priority)
   ExecuteDeltaHedge();
   
   // 2. Execute Gamma Strategy (Secondary)
   ExecuteGammaStrategy();
   
   // 3. Time-based opportunities (Near expiry)
   if(T * 365 < 30) // Less than 30 days to expiry
   {
      Print("Near expiry detected: ", T*365, " days - Monitoring for time decay opportunities");
      
      // Consider closing positions or adjusting strategy near expiry
      if(currentGamma > GammaThreshold * 3)
      {
         Print("High Gamma near expiry - Potential for volatility plays");
      }
   }
}

Dieser Abschnitt des Codes implementiert die zentrale Entscheidungsfindungsmaschine, die griechische Berechnungen in automatische Handelsaktionen umwandelt. Die Funktion CalculateDynamicFrequency() stellt ein, wie häufig der Algorithmus auf der Grundlage der aktuellen Gamma-Werte nach Absicherungsmöglichkeiten sucht. Ein hohes Gamma bedeutet schnelle Veränderungen im Delta, sodass das System die Überwachung auf einmal pro Minute erhöht. Bei mittlerem Gamma wird die vom Nutzer festgelegte Basisfrequenz verwendet, während bei niedrigem Gamma das Auswertungsintervall auf fünf Minuten reduziert wird. Diese dynamische Zeitsteuerung gewährleistet die Reaktionsfähigkeit bei volatilen Bedingungen und reduziert unnötige Handelsaktivitäten in ruhigeren Märkten. Die Funktion ExecuteTrade() bietet dann eine robuste, risikokontrollierte Möglichkeit, Handelsgeschäfte zu platzieren, indem sie Stop-Loss- und Take-Profit-Niveaus basierend auf dem Punktwert des Symbols anwendet und detaillierte Protokolle sowohl für erfolgreiche als auch für fehlgeschlagene Orderausführungen liefert.

Die Gamma-basierte Handelslogik, die durch ExecuteGammaStrategy() implementiert wird, konzentriert sich auf das Ergreifen von Gelegenheiten, wenn Gamma hoch ist – ein Umfeld, in dem der Preis empfindlicher ist und Intraday-Bewegungen ausgeprägter werden. Wenn Gamma den 1,5-fachen Schwellenwert überschreitet und der Basiswert in der Nähe seines Ausübungspreises gehandelt wird, generiert das System Signale für KAUF oder VERKAUF in Abhängigkeit von den Delta-Extremen: Ein hohes Delta deutet auf einen Abwärtstrend hin, ein niedriges Delta auf einen Abwärtstrend. In der Zwischenzeit arbeitet die Delta-Hedge-Engine (ExecuteDeltaHedge()) kontinuierlich daran, das Portfolio wieder in einen delta-neutralen Zustand zu bringen. Es berechnet das kombinierte Delta der Basiswert- und Optionspositionen, prüft auf Abweichungen, die über den zulässigen Schwellenwert hinausgehen, und führt Gegengeschäfte aus, um das Risiko auszugleichen.

Mit der Funktion ExecuteCombinedStrategy() wird alles in einen einheitlichen Handelszyklus integriert. Sie berechnet die „Griechen“ neu, gibt Diagnoseinformationen aus, führt Delta-Hedging als primären Sicherheitsmechanismus durch und prüft dann auf Gamma-Scalping-Möglichkeiten als sekundäre Handelsgeschäfte. Darüber hinaus überwacht es die Zeit bis zum Verfall und zeigt Szenarien auf, in denen ein hohes Gamma und eine kurze Laufzeit zu einer erhöhten Volatilität und potenziellen Handelsvorteilen führen. Diese hierarchische Struktur – Delta-Hedge an erster Stelle, Gamma-Chancen an zweiter Stelle und zeitbasierte Logik an letzter Stelle – stellt sicher, dass das System die Risikokontrolle aufrechterhält und gleichzeitig kurzfristige, durch die griechische Dynamik bedingte Mikrostrukturmöglichkeiten nutzt.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   static datetime lastCheck = 0;
   
   // Update display on every tick
   UpdateGreeksDisplay();
   
   // Execute strategy at dynamic frequency
   if(TimeCurrent() - lastCheck >= currentHedgeFrequency * 60)
   {
      lastCheck = TimeCurrent();
      
      Print("\n=== STRATEGY CYCLE ===");
      Print("Time: ", TimeToString(TimeCurrent()));
      
      // Execute combined gamma/delta strategy
      ExecuteCombinedStrategy();
      
      Print("=== CYCLE COMPLETE ===\n");
   }
}

void OnTrade()
{
   Print("Position Update - Total Positions: ", PositionsTotal());
   portfolioDelta = CalculatePortfolioDelta();
}

//+------------------------------------------------------------------+
//| Monitoring and Reporting                                         |
//+------------------------------------------------------------------+
void UpdateGreeksDisplay()
{
   double S = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double T = TimeToExpiry();
   
   currentDelta = CalculateDelta(S, StrikePrice, Volatility, T, RiskFreeRate, DividendYield);
   currentGamma = CalculateGamma(S, StrikePrice, Volatility, T, RiskFreeRate, DividendYield);
   portfolioDelta = CalculatePortfolioDelta();
   
   currentHedgeFrequency = CalculateDynamicFrequency();
   
   Comment(
      "EU50 Gamma/Delta Auto Trader\n",
      "Price: ", DoubleToString(S, 2), " | Strike: ", StrikePrice, "\n",
      "Option Delta: ", DoubleToString(currentDelta, 4), 
      " | Gamma: ", DoubleToString(currentGamma, 6), "\n",
      "Portfolio Delta: ", DoubleToString(portfolioDelta, 4), 
      " | Target: ", targetDelta, "\n",
      "Hedge Freq: ", currentHedgeFrequency, "min",
      " | Days to Expiry: ", DoubleToString(T*365, 0), "\n",
      "Trades: ", PositionsTotal(), " | Mode: ", EnableTrading ? "LIVE" : "DEMO"
   );
}

Die Funktion OnTick() dient als Hauptausführungsschleife des Expert Advisors und wird jedes Mal ausgeführt, wenn ein neuer Markttick eintrifft. Zunächst wird die Chart-Anzeige aktualisiert, sodass der Händler Delta, Gamma, Hedge-Frequenz und andere wichtige Metriken visuell überwachen kann. Die Funktion prüft dann, ob seit dem letzten Hedge-Zyklus genügend Zeit verstrichen ist, wobei die dynamisch angepasste Frequenz verwendet wird, die sich aus den Gamma-Werten ergibt. Wenn die Zeitbedingung erfüllt ist, wird ein vollständiger Strategiezyklus eingeleitet, der Zeitstempel protokolliert und ExecuteCombinedStrategy() aufgerufen, das Delta-Hedging, Gamma-Scalping und eine auf dem Ablaufdatum basierende Logik verarbeitet. Diese Struktur stellt sicher, dass der EA während der Gamma-Perioden mit hoher Volatilität präzise reagiert und gleichzeitig unnötigen Handel während stabiler Bedingungen vermeidet. Die zugehörige Ereignisbehandlung von OnTrade() liefert Echtzeit-Updates, wenn sich eine Position ändert, und berechnet das Portfolio-Delta neu, um das Risikomodell mit dem tatsächlichen Marktengagement zu synchronisieren.

Die Berichtsfunktion UpdateGreeksDisplay() fasst alle Berechnungen zusammen und füllt das Dashboard auf dem Bildschirm auf. Sie berechnet den zugrunde liegenden Kurs, die Zeit bis zum Verfall, Delta, Gamma, Portfolio-Delta und die dynamische Hedge-Frequenz neu. Diese Metriken werden dann über das Comment()-Panel in einem strukturierten Format angezeigt, sodass der Händler den Status des Systems sofort erkennen kann – ob es im Live- oder Demomodus arbeitet, wie viele Handelsgeschäfte offen sind und wie nahe das Portfolio der Delta-Neutralität ist. Durch die Aktualisierung dieses Panels bei jedem Tick bietet der EA ein kontinuierliches Situationsbewusstsein und verwandelt abstrakte griechische Werte in eine Echtzeitvisualisierung von Risiko und Strategiebereitschaft.

Ergebnisse der Backtests

Die Backtests wurde für das Symbol „EU50cash“ im 1H-Zeitrahmen über ein etwa zweimonatiges Testfenster (14. Februar 2025 bis 11. April 2025) mit den folgenden Einstellungen ausgewertet:

Hier nun die Kapitalkurve und die Backtest-Ergebnisse:

Aus den Ergebnissen geht hervor, dass die Gamma/Delta-Automatik sowohl als Mikrostruktur-Scalper als auch als Hedging-Maschine korrekt funktioniert und viele kleine, risikoarme Gewinne generiert, während das Risiko streng kontrolliert wird. Das System ist ideal für Händler, die Kapitalerhalt, marktneutrales Engagement und stetigen Zinseszins gegenüber aggressiver Gewinnjagd bevorzugen.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass wir die gesamte Automatisierungspipeline der „Griechen“ im Black-Scholes-Modell in einen umsetzbaren Handelsrahmen überführt haben, der die theoretischen Sensitivitätsmaße mit der Echtzeit-Marktausführung verbindet. Wir haben schnelle numerische Funktionen für Delta, Gamma und die Zeit bis zum Ablauf implementiert, ein dynamisches, von der Gamma-Intensität gesteuertes Frequenzsystem aufgebaut und eine Absicherungslogik entwickelt, die in der Lage ist, Delta-Neutralität aufrechtzuerhalten und gleichzeitig Gamma-Skalierungsbedingungen opportunistisch auszunutzen. Durch die Kombination von Delta-Hedging, Gamma-basierten Mikrostruktursignalen, verfallssensitiver Logik und einem Live-Dashboard zur Überwachung des Charts haben wir die griechischen Analysen in eine vollständige automatisierte Engine für EU50 und ähnliche Instrumente verwandelt.

Zusammenfassend lässt sich sagen, dass diese Automatisierung der „Griechen“ Händlern ein leistungsfähiges Instrument bietet, um kurzfristige Volatilitäts- und Mikrostrukturverschiebungen präzise und risikoarm zu steuern. Durch die kontinuierliche Neuberechnung von Sensitivitäten, die Anpassung des Hedge-Timings auf der Grundlage von Gamma und die Ausführung von Handelsgeschäften nur dann, wenn dies statistisch gerechtfertigt ist, ermöglicht das Modell eine disziplinierte, datengesteuerte Entscheidungsfindung – weit über das hinaus, was der manuelle Handel leisten kann. Ob für Hedging, Scalping oder Volatility Harvesting, dieser Ansatz ermöglicht Händlern eine Risikokontrolle auf institutionellem Niveau und taktische Reaktionsfähigkeit.