Optionshandel ohne Optionen (Teil 2): Einsatz im Live-Handel

Einführung

Im ersten Teil der Serie haben wir kurz das Finanzinstrument Option, seine Möglichkeiten, sowie Vor- und Nachteile beschrieben. Wir haben eine Theorie und die praktische Implementierung einer Methode zur Emulation einer Option unter Verwendung eines Basiswerts in MQL5 entwickelt. Es ist an der Zeit, Optionen im realen Markthandel einzusetzen. 

Zu diesem Zweck müssen wir einen EA erstellen, der die Emulationsniveaus von Optionen in reale Orders und Positionen auf dem Basiswert umsetzt und die resultierende Gesamtposition kontinuierlich neu ausbalanciert.

Anwendung im realen Handel

Sehen wir uns zunächst an, welche Strategien sich im Handel einsetzen lassen. Hier betrachten wir nur spekulative Strategien. Beginnen wir mit den einfachsten – dem Kauf/Verkauf einzelner Optionen. Dazu erstellen wir eine Tabelle mit allen möglichen Optionen.

Einfache Handelsstrategien und Bedingungen für deren Einsatz

Long Call

• Idee: Kauf einer Call-Option 
• Bedingung: Wenn Vertrauen in einen Preisanstieg des Basiswerts besteht
• Gewinn: unbegrenzt
• Risiko: für die Option gezahlte Prämie (bei der Emulation nicht vorhanden)

Long Put

• Idee: Kauf einer Put-Option in Erwartung eines Preisrückgangs des Basiswerts.
• Bedingung: Wenn Vertrauen in einen Preisrückgang des Basiswerts besteht.
• Gewinn: unbegrenzt
• Risiko: für die Option gezahlte Prämie (bei der Emulation nicht vorhanden)

Short Call

• Idee: Verkauf einer Call-Option in der Erwartung, dass der Preis des Basiswerts nicht steigt, aber auch nicht unbedingt fallen muss.
• Bedingung: Wenn davon ausgegangen wird, dass der Basiswert nicht steigen wird.
• Gewinn: die vom Optionskäufer gezahlte Prämie (die im Emulationsmodell nicht existiert).
• Risiko: Unbeschränkt

Short Put

• Idee: Verkauf einer Put-Option in der Erwartung, dass der Preis des Basiswerts nicht fällt, aber auch nicht unbedingt steigen muss.
• Bedingung: Wenn davon ausgegangen wird, dass der Basiswert nicht fallen wird.
• Gewinn: die vom Optionskäufer gezahlte Prämie (die im Emulationsmodell nicht existiert).
• Risiko: unbegrenzt

Anmerkung:

• Der Verkauf emulierter Einzeloptionen ergibt wenig Sinn, da es dafür keine Prämie gibt. Um jedoch weitere Optionskonstruktionen (börslich ausgedrückt: Optionsportfolios) zu erstellen, sollten daher alle Optionstypen implementiert werden.
• Beim Kauf emulierter Einzeloptionen wird natürlich keine Prämie gezahlt. Aber bei der Neugewichtung eines Portfolios kann sich ein gewisser Verlust „ansammeln“ (dies kann als Äquivalent zur Zahlung einer Prämie betrachtet werden). Dessen Höhe hängt von der spezifischen Preisänderung des Basiswerts und der Haltedauer der Position ab. Im Allgemeinen ist dieser Verlust mit der Prämie vergleichbar.

Wir entwickeln einen EA zur Umsetzung einer Handelsstrategie.

Die Basisklasse TOptionBase und die Optionsklassen OptionLongCall, OptionLongPut, OptionShortCall, OptionShortPut bleiben unverändert (siehe den vorherigen Artikel der Serie). Fügen wir nun eine Basisklasse für eine Optionskonstruktion hinzu, die es uns später ermöglicht, Optionskonstruktionen beliebiger Komplexität zu erstellen.

Die Klasse TOptionConstructionBase wird unten gezeigt. Wir haben sie von der Standardklasse CList abgeleitet, die Teil der MQL5-Bibliotheken ist. Um auf CList zugreifen zu können, müssen wir am Anfang folgende Zeile hinzufügen:

#include    <Arrays\List.mqh>

Dies ermöglicht es uns, die Optionslisten zu bearbeiten, um die gewünschten Gesamtmerkmale des Portfolios zu erhalten. Schauen wir uns also die Optionskonstruktionsklasse an:

// =====================================================================
//  Base class of the option construction - derived from 'CList':
// =====================================================================
class TOptionConstructionBase : public CList
{
protected:
  ENUM_OPTION_CONSTRUCTION    type_enum;
  double    total_delta;
  bool      is_option_construction_inited_Flag;

public:
  // ---------------------------------------------------------------------
  //  Destructor:
  // ---------------------------------------------------------------------
  ~TOptionConstructionBase()
  {
    this.Clear();
  }
  // ---------------------------------------------------------------------
  //  Constructor:
  // ---------------------------------------------------------------------
  TOptionConstructionBase(ENUM_OPTION_CONSTRUCTION _type_enum)
  :
  type_enum(_type_enum),
  total_delta(0.0),
  is_option_construction_inited_Flag(false),
  CList()
  {
    this.FreeMode(true);
  }
  // ---------------------------------------------------------------------
  //  Get the value of the previously calculated normalized delta:
  // ---------------------------------------------------------------------
  double GetOptionConstructionDelta()
  {
    return(this.total_delta);
  }
  // ---------------------------------------------------------------------
  //  Get the value of the general initialization flag of the option construction:
  // ---------------------------------------------------------------------
  bool IsOptionConstructionInited()
  {
    return(this.is_option_construction_inited_Flag);
  }
  // ---------------------------------------------------------------------
  //  Set the delta normalization range for the central strike:
  // ---------------------------------------------------------------------
  void SetOptionConstructionRange(const double& _strike[], const double& _norm_price[])
  {
    this.is_option_construction_inited_Flag = true;
    if(this.Total() > 0)
    {
      int    i = 0;
      TOptionBase* curr_option = this.GetFirstNode();
      while(curr_option != NULL)
      {
        curr_option.SetRange(_strike[i], _norm_price[i]);
        if(curr_option.IsRangeInited() == true)
        {
          this.is_option_construction_inited_Flag = this.is_option_construction_inited_Flag && true;
        }
        else
        {
          this.is_option_construction_inited_Flag = false;
        }
        curr_option = this.GetNextNode();
        i++;
      }
    }
  }
  // ---------------------------------------------------------------------
  //  Delta update iterator:
  // ---------------------------------------------------------------------
  double UpdateOptionConstructionDelta(const double _price)
  {
    this.total_delta = 0.0;
    if(this.Total() > 0)
    {
      TOptionBase* curr_option = this.GetFirstNode();
      while(curr_option != NULL)
      {
        this.total_delta += curr_option.UpdateDelta(_price);
        curr_option = this.GetNextNode();
      }
    }

    return(this.total_delta);
  }
  // ---------------------------------------------------------------------
  //  Create an option construction:
  // ---------------------------------------------------------------------
  virtual void CreateOptionConstruction(const double _k, const double _s, const int _digits) = 0;
};
// ---------------------------------------------------------------------

Schauen wir uns das genauer an. Wie wir sehen können, befindet sich ganz unten im gezeigten Code eine Deklaration der abstrakten Methode CreateOptionConstruction, daher ist die Basisklasse selbst abstrakt. Diese Methode ist für die Erstellung der Optionskonstruktion verantwortlich und wird in abgeleiteten Klassen definiert. Die Methode nimmt die Parameter _k, _s und _digits entgegen. Die ersten beiden sind die Werte von K und S in der Sigmoidfunktion, die die Option emuliert. Der letzte ist die Anzahl der Dezimalstellen des Basiswerts.

Außerdem haben wir eine Enumeration für den Typ ENUM_OPTION_CONSTRUCTION implementiert. In diesem Stadium sieht sie wie folgt aus:

// ---------------------------------------------------------------------
//  Option construction:
// ---------------------------------------------------------------------
enum ENUM_OPTION_CONSTRUCTION
{
  ENUM_OPTION_CONSTRUCTION_RISING = 0,                                // Base Active Rising - Long CALL
  ENUM_OPTION_CONSTRUCTION_FALLING = 1,                               // Base Active Falling - Long PUT
  ENUM_OPTION_CONSTRUCTION_NOT_RISING = 2,                            // Base Active NOT Rising - Short CALL
  ENUM_OPTION_CONSTRUCTION_NOT_FALLING = 3,                           // Base Active NOT Falling - Short PUT
};
// ---------------------------------------------------------------------

In Zukunft werden wir komplexere Konstruktionen und neue Typen zur Enumeration hinzufügen. Dieser Typ wird beim Erstellen eines Objekts als Parameter an den Klassenkonstruktor übergeben.

Die Methode SetOptionConstructionRange(const double& _strike[], const double& _norm_price[]) ermöglicht das Festlegen des Delta-Normalisierungsbereichs für den zentralen Ausübungspreis für jede der in der Konstruktion enthaltenen Optionen. Die Parameter der Ausübungspreise und Normalisierungsbereiche werden als Referenzen auf Arrays übergeben, die die entsprechenden Werte enthalten. Die Dimensionen der Arrays sollten der Anzahl der Optionen in der Optionskonstruktion entsprechen.

Für die oben genannten Konstruktionen ist die Dimension immer gleich eins. In dieser Testversion wird die Dimensionsprüfung nicht durchgeführt, sie kann jedoch in der Arbeitsversion für den echten Handel leicht hinzugefügt werden. Da die Optionskonstruktion anfänglich spezifiziert ist, sind die Dimensionen der Arrays (tatsächlich die Anzahl der Optionen) im Voraus bekannt.

Außerdem definiert die Basisklasse die Methode UpdateOptionConstructionDelta(const double _price) zur Aktualisierung des Gesamtdeltas der Optionskonstruktion, die das berechnete Gesamtdelta zurückgibt. Der Eingabeparameter der Methode ist der Preis des Basiswerts. Diese Methode verwendet Methoden der Klasse CList, um über alle Elemente der Liste zu iterieren.

Als Nächstes leiten wir konkrete Optionskonstruktionen von der Basisklasse ab. Da die gesamte Funktionalität in der Basisklasse enthalten ist, haben die abgeleiteten Klassen eine recht einfache Form:

// =====================================================================
//  Class of option construction of 'Base Active Rising' type:
// =====================================================================
class BaseActiveRisingOptionConstruction : public TOptionConstructionBase
{
public:
  // ---------------------------------------------------------------------
  //  Constructor:
  // ---------------------------------------------------------------------
  BaseActiveRisingOptionConstruction()
  :
  TOptionConstructionBase(ENUM_OPTION_CONSTRUCTION_RISING)
  {
  }
  // ---------------------------------------------------------------------
  //  Create an option construction:
  // ---------------------------------------------------------------------
  virtual void    CreateOptionConstruction(const double _k, const double _s, const int _digits) override
  {
    this.Add(new OptionLongCall(_k, _s, _digits));
  }
};

// =====================================================================
//  Class of option construction of 'Base Active Falling' type:
// =====================================================================
class BaseActiveFallingOptionConstruction : public TOptionConstructionBase
{
public:
  // ---------------------------------------------------------------------
  //  Constructor:
  // ---------------------------------------------------------------------
  BaseActiveFallingOptionConstruction()
  :
  TOptionConstructionBase(ENUM_OPTION_CONSTRUCTION_FALLING)
  {
  }
  // ---------------------------------------------------------------------
  //  Create an option construction:
  // ---------------------------------------------------------------------
  virtual void    CreateOptionConstruction(const double _k, const double _s, const int _digits) override
  {
    this.Add(new OptionLongPut(_k, _s, _digits));
  }
};

// =====================================================================
//  Class of option construction of 'Base Active NOT Rising' type:
// =====================================================================
class BaseActiveNotRisingOptionConstruction : public TOptionConstructionBase
{
public:
  // ---------------------------------------------------------------------
  //  Constructor:
  // ---------------------------------------------------------------------
  BaseActiveNotRisingOptionConstruction()
  :
  TOptionConstructionBase(ENUM_OPTION_CONSTRUCTION_NOT_RISING)
  {
  }
  // ---------------------------------------------------------------------
  //  Create an option construction:
  // ---------------------------------------------------------------------
  virtual void    CreateOptionConstruction(const double _k, const double _s, const int _digits) override
  {
    this.Add(new OptionShortCall(_k, _s, _digits));
  }
};

// =====================================================================
//  Class of option construction of 'Base Active NOT Falling' type:
// =====================================================================
class BaseActiveNotFallingOptionConstruction : public TOptionConstructionBase
{
public:
  // ---------------------------------------------------------------------
  //  Constructor:
  // ---------------------------------------------------------------------
  BaseActiveNotFallingOptionConstruction()
  :
  TOptionConstructionBase(ENUM_OPTION_CONSTRUCTION_NOT_FALLING)
  {
  }
  // ---------------------------------------------------------------------
  //  Create an option construction:
  // ---------------------------------------------------------------------
  virtual void    CreateOptionConstruction(const double _k, const double _s, const int _digits) override
  {
    this.Add(new OptionShortPut(_k, _s, _digits));
  }
};

// ---------------------------------------------------------------------

Alles, was in der abgeleiteten Klasse getan werden muss, ist die Definition der Methode CreateOptionConstruction zur Optionskonstruktion. In dieser Methode erstellen wir ein Objekt der Option (oder eine Gruppe von Optionen), die wir benötigen, und fügen das erstellte Objekt der Liste hinzu, indem wir die Methode CList::Add aufrufen.

Diese Klassen befinden sich in der Datei OptionEmulatorA2.mqh, die dem Artikel beigefügt ist.

Eingabeparameter des EAs

Kommen wir nun zur Implementierung des eigentlichen EAs für die Emulation mit realem Positionsmanagement. Fügen wir zunächst eine Enumeration hinzu, die den allgemeinen Status des EAs oder den Handelsstatus definiert:

// ---------------------------------------------------------------------
//  Current trading status:
// ---------------------------------------------------------------------
enum ENUM_TRADE_MODE_STATE
{
  ENUM_TRADE_MODE_STARTED,                                            // trading is ONGOING, positions are HANDLED
  ENUM_TRADE_MODE_STOPPED,                                            // trading is STOPPED, all positions are CLOSED
  ENUM_TRADE_MODE_PAUSED,                                             // trading is SUSPENDED by the operator, existing positions are NOT HANDLED
  ENUM_TRADE_MODE_WAITING,                                            // trading is AWAITING automatic renewal, existing positions are HANDLED, IF POSSIBLE
};
// ---------------------------------------------------------------------

In der ersten Version des EAs werden nur zwei Zustände verwendet: Handel gestoppt und Handel läuft. Der Handel beginnt, wenn der EA nach seiner Initialisierung gestartet wird, und endet, sobald die Ablaufzeit erreicht ist. Wir verwenden tägliche Optionen mit obligatorischem Ablauf vor Beginn eines neuen Tages. 

Fügen wir die erforderlichen externen Parameter zum EA hinzu:

// =====================================================================
//  Externally set parameters:
// =====================================================================
input ENUM_OPTION_CONSTRUCTION    OptionConstruction = ENUM_OPTION_CONSTRUCTION_RISING;  // Option Construction
input ulong     BaseMagic = 10000UL;                                  // Base Magic
input int       MinLotsMultiplier = 1;                                // Min Lots Multiplier
// ---------------------------------------------------------------------
input int       AddNewFromHours = 0;                                  // Add New Hours (0...23) From
input int       AddNewToHours = 24;                                   // Add New Hours (1...24) To
input int       ExpirationTimeHours = 24;                             // Expiration Time, Hours (1...24)
input int       ExpirationTimeMinutes = 0;                            // Expiration Time, Minutes (0...59)
// ---------------------------------------------------------------------
input double    ZeroDelta = 0.01;                                     // Zero Delta (0.01...0.1)
input string    ForceAutoExpirationTime = "23:50";                    // Force Auto Expiration Time (MT5 Server)
input int       ADRDaysNumber = 20;                                   // ADR Days Number
// ---------------------------------------------------------------------

Externe Parameter, die Fragen aufwerfen könnten:

• BaseMagic – der Basiswert der „Magic“-Nummer (beim Öffnen einer Position wird die mit 100 multiplizierte Nummer der Options-Emulationsebene dazu addiert);
• MinLotsMultiplier – Mindest-Lot-Multiplikator bei der Bestimmung des Positionsvolumens auf jeder Ebene;
• AddNewFromHours – Beginn der Arbeit des EAs innerhalb des Tages, in Stunden (von 0 bis 23 Stunden);
• AddNewToHours – Abschluss der Arbeit des EAs innerhalb eines Tages, in Stunden (von 1 bis 24 Stunden);
• ExpirationTimeHours – Ablaufzeit der Optionskonstruktion innerhalb eines Tages, in Stunden von 1 bis 24 Stunden;
• ExpirationTimeMinutes – Ablaufzeit der Optionskonstruktion innerhalb eines Tages, in Minuten von 0 bis 59 Minuten;
• ForceAutoExpirationTime – Zeitpunkt für das erzwungene Ablaufende des EAs im Format „hh:mm“;
• ADRDaysNumber – Anzahl der Tage für die Berechnung der historischen Volatilität (HV).

Trading EA

Die folgenden Funktionen des Trading-EA sind von Interesse:

//---------------------------------------------------------------------
//    Get normalized trading volume:
//---------------------------------------------------------------------
//  • the required lot at the input;
//  • normalized lot at the output;
//---------------------------------------------------------------------
double
NormalizeLots(const double _requied_lots)
{
  double    lots, koeff;
  int       nmbr;

  if(min_trade_volume_step > 0.0)
  {
    koeff = 1.0 / min_trade_volume_step;
    nmbr = (int)MathLog10(koeff);
  }
  else
  {
    koeff = 1.0 / min_trade_volume;
    nmbr = 2;
  }
  lots = MathFloor(_requied_lots * koeff) / koeff;

  //  Lot limit from below:
  if(lots < min_trade_volume)
  {
    lots = min_trade_volume;
  }

  //  Upper lot limit:
  if(lots > max_trade_volume)
  {
    lots = max_trade_volume;
  }

  lots = NormalizeDouble(lots, nmbr);
  return(lots);
}

Eine Lot-Normalisierung ist erforderlich, da Instrumente im realen Handel diskrete Änderungen im Handelsvolumen aufweisen. Zusätzlich sind die Anzahl der Stellen in der Volumendarstellung sowie die minimalen/maximalen Volumenwerte begrenzt. All diese Anforderungen werden in der oben vorgestellten Funktion NormalizeLots berücksichtigt.

// ---------------------------------------------------------------------
//    Normalize price considering the step of quote change:
// ---------------------------------------------------------------------
double
NormalizePrice(const double _price)
{
  //  Minimum step of change of quotes in points:
  double    min_price_step = NormalizeDouble(symbol_tick_size / Point(), 0 );

  double    norm_price = NormalizeDouble(NormalizeDouble((NormalizeDouble(_price / Point(), 0 )) / min_price_step, 0 ) * min_price_step * Point(), Digits());
  return(norm_price);
}
// ---------------------------------------------------------------------

Hier werden die während der Initialisierung erhaltenen Werte der globalen Variablen verwendet:

double  min_trade_volume = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MIN);
double  max_trade_volume = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_MAX);
double  min_trade_volume_step = SymbolInfoDouble(Symbol(), SYMBOL_VOLUME_STEP);
double  symbol_tick_size = SymbolInfoDouble(Symbol(), SYMBOL_TRADE_TICK_SIZE);

Der Algorithmus des EA basiert auf der Verarbeitung jedes neuen Ticks in OnTick. Eine vereinfachte Struktur des Handlers ist unten dargestellt:

//    Handle a new tick (if all necessary conditions are met):
if(is_bars_loaded_Flag == true && is_adr_levels_calculated_Flag == true && option_construstion_Ptr.IsOptionConstructionInited() == true)
{
  if(SymbolInfoTick(Symbol(), tick) == true)
  {
    ask_option_construction_delta = option_construstion_Ptr.UpdateOptionConstructionDelta(tick.ask);
    bid_option_construction_delta = option_construstion_Ptr.UpdateOptionConstructionDelta(tick.bid);
    curr_option_construction_delta = option_construstion_Ptr.UpdateOptionConstructionDelta((tick.ask + tick.bid) / 2.0);

    if(is_first_ea_starting == true)
    {
      is_first_ea_starting = false;
Print("CurrDelta : ", DoubleToString(curr_option_construction_delta, 3), "  BidDelta : ", DoubleToString(bid_option_construction_delta, 3), "  AskDelta : ", DoubleToString(ask_option_construction_delta, 3));
    }

    //  Calculate the current REQUIRED POSITION VOLUME with a check to see if the option emulation level has changed:
    if(option_contruction_volume_Ptr.UpdateOptionLevel(curr_option_construction_delta, prev_option_level_value) == true)
    {
      //  Current sign of the option emulation level (+1/0/-1):
      live_option_level_sign = option_contruction_volume_Ptr.GetOptionLevelSign();
                
      //  Current value (modulo) of the option emulation level (0/1/2/3/4/5/6/7/8/9/10):
      live_option_level_value = option_contruction_volume_Ptr.GetOptionLevel();

      //  It is necessary to change the position volume - rebalance the option construction:
      if(live_option_level_value > 0)
      {
        live_position_lots_abs = NormalizeLots(live_option_level_value * min_trade_volume_step * MinLotsMultiplier);
      }
      else
      {
        live_position_lots_abs = 0.0;
      }

Print("#NEW LEVEL  Position Volume : ", DoubleToString(live_option_level_value * live_option_level_sign * MinLotsMultiplier, 1), "  CurrDelta : ", DoubleToString(curr_option_construction_delta, 3), "  Levels Prev/Live: ", prev_option_level_value, "/", live_option_level_value);

      //  If we are in 'STARTED' mode, adjust the total volume of virtual and real positions:
      if(current_trade_mode_state == ENUM_TRADE_MODE_STARTED)
      {
        //  If the value of the option emulation LEVEL has INCREASED, then positions need to be added to new levels:
        if(live_option_level_value > prev_option_level_value)
        {
          //  BUY positions:
          if(live_option_level_sign == 1)
          {
            //  If the interval for placing new orders has not yet passed:
            if(CheckAddingNew(tick.time) == true)
            {
              //  Set real orders at new levels:
              OpenBuyLevels(live_option_level_value, live_option_level_value - prev_option_level_value);
            }
          }
          //  SELL positions:
          else if(live_option_level_sign == -1)
          {
            //  If trading is allowed:
            if(is_trade_allowed_Flag == true)
            {
              //  If the interval for placing new orders has not yet passed:
              if(CheckAddingNew(tick.time) == true)
              {
                //  Set real orders at new levels:
                OpenSellLevels(live_option_level_value, live_option_level_value - prev_option_level_value);
              }
            }
          }
          prev_option_level_value = live_option_level_value;
          prev_option_level_sign = live_option_level_sign;
        }
        //  If the value of the option emulation LEVEL has DECREASED, then it is necessary to close some or all positions at the previous levels:
        else if(live_option_level_value < prev_option_level_value)
        {
          //  BUY positions:
          if(live_option_level_sign == 1)
          {
            //  If trading is allowed:
            if(is_trade_allowed_Flag == true)
            {
              for(int curr_level = prev_option_level_value; curr_level > live_option_level_value; curr_level--)
              {
                CloseLevelPositions(Symbol(), POSITION_TYPE_BUY, curr_level);
              }
            }
          }
          //  SELL positions:
          else if(live_option_level_sign == -1)
          {
            //  If trading is allowed:
            if(is_trade_allowed_Flag == true)
            {
              for(int curr_level = prev_option_level_value; curr_level > live_option_level_value; curr_level--)
              {
                CloseLevelPositions(Symbol(), POSITION_TYPE_SELL, curr_level);
              }
            }
          }
          //  The current value (modulo) of the delta level during option emulation has become ZERO (all positions should be closed):
          else  if(live_option_level_sign == 0)
          {
            //  If trading is allowed:
            if(is_trade_allowed_Flag == true)
            {
              if(prev_option_level_sign == 1)
              {
                for(int curr_level = prev_option_level_value; curr_level > live_option_level_value; curr_level--)
                {
                  CloseLevelPositions(Symbol(), POSITION_TYPE_BUY, curr_level);
                }
              }
              else if(prev_option_level_sign == -1)
              {
                for(int curr_level = prev_option_level_value; curr_level > live_option_level_value; curr_level--)
                {
                  CloseLevelPositions(Symbol(), POSITION_TYPE_SELL, curr_level);
                }
              }
            }
            live_position_lots_abs = 0.0;
            live_option_level_sign = 0;
          }
        }
      }
      prev_option_level_value = live_option_level_value;
      prev_option_level_sign = live_option_level_sign;      }
    }
  }
}

Die Änderung des Options-Emulationsniveaus wird durch Aufruf der Methode UpdateOptionLevel verfolgt. Wenn sich das Niveau geändert hat, gibt diese Methode true zurück. Hier vergleichen wir die aktuellen und die vorherigen (vom vorherigen Tick) Werte der Options-Emulationsniveaus.

Wenn es notwendig ist, Positionen neu auszubalancieren, prüfen Sie, ob das Options-Emulationsniveau gestiegen oder gefallen ist. Wenn es gestiegen ist, ist das Hinzufügen von Positionen erforderlich. Wenn es gefallen ist, müssen einige Positionen geschlossen werden. Wenn das Emulationsniveau null wird, schließen wir alle offenen Positionen. Auf diese Weise erfolgt eine Neugewichtung der Gesamtposition.

Beachten Sie, dass wir den Durchschnitt zwischen Bid und Ask als Preis für die Berechnung des aktuellen Deltas der Optionskonstruktion verwenden. Dies trägt dazu bei, die Abhängigkeit von Delta-Änderungen von Spread-Änderungen zu verringern. Der vollständige Text des EA befindet sich in den an diesen Artikel angehängten Dateien.

Marktorders werden beim Öffnen und Schließen von Positionen verwendet. Dies geschieht, um die Überprüfung der EA-Arbeit zu vereinfachen (es gibt eine Garantie, dass die Order ausgeführt wird). In Zukunft wird empfohlen (und soll implementiert werden), für das Öffnen von Positionen auf Limit-Orders umzusteigen. Dies reduziert die Provisionskosten und verbessert die Handelsergebnisse durch den Wegfall des Spreads beim Eingehen von Trades.

Test der Emulation und Handel in Echtzeit

Nehmen wir an, wir haben entschieden, dass sich der EURUSD-Preis im Laufe des Tages überwiegend nach oben bewegen wird. Legen wir den Typ der Optionskonstruktion auf OptionConstruction = ENUM_OPTION_CONSTRUCTION_RISING fest. Ein Beispiel für einen EA, der die Optionskonstruktion Base Active Rising – Long CALL simuliert, ist in den folgenden Abbildungen dargestellt: Abb. 1 – vom Tagesbeginn, Abb. 2 – vergrößerter Ansicht. Die Emulationsstufen 1 bis 9 wurden ausgelöst. Die Neugewichtung der Stufen wurde zu Beginn des EA-Betriebs durchgeführt:

Abb. 1. Base Active Rising – Long CALL Optionskonstruktion in Aktion – Übersicht

Abb. 2. Base Active Rising – Long CALL Optionskonstruktion in Aktion (vergrößert)

Abb. 3. Aktueller Stand der Positionen während der Emulation der Base Active Rising – Long CALL Optionskonstruktion

 

Abb. 4. Das Ergebnis der Neugewichtung während der Emulation der Optionskonstruktion Base Active Rising – Long CALL in Form von Trades aus der Handelshistorie

Nehmen wir nun an, dass wir am nächsten Tag entscheiden, dass sich der Preis umkehren und fallen wird. Stellen Sie den Typ der Optionskonstruktion OptionConstruction = ENUM_OPTION_CONSTRUCTION_FALLING ein. Diesmal war das Glück nicht auf unserer Seite – der Preis drehte sich bis zum Ende des Tages gegen uns und wir erlitten einige Verluste. Abb. 5 zeigt die Entwicklung einer gegebenen Optionskonstruktion. Die Emulationsstufen von 1 bis 5 wurden geöffnet. Der aufgezeichnete Verlust durch die Neugewichtung betrug USD -5,77 (siehe Abb. 6).

Abb. 5. Base Active Rising – Long Put Optionskonstruktion in Aktion – Übersicht

Abb. 6. Das Ergebnis der Neugewichtung während der Emulation der Base Active Rising – Long Put Optionskonstruktion in Form von Trades aus der Handelshistorie

Das maximale Gesamtvolumen der Positionen kann den Wert von 0,1 = 10 Stufen * 0,01 erreichen – dies ist das Zielvolumen der Optionskonstruktion bei einem minimalen Lot-Multiplikatorwert von eins. Wie aus Abb. 4 ersichtlich ist, erhielten wir als Ergebnis der Neugewichtung der Optionskonstruktion im ersten Fall einen festen Verlust von USD -2,39 und im zweiten von USD -5,77 (siehe Abb. 6). Dies ist analog zu der Prämie, die für den Kauf einer Option gezahlt wird. Wie im Parameter ForceAutoExpirationTime = „23:50“ des EAs angegeben, lief die Optionskonstruktion um 23:50 Uhr ab und sicherte im ersten Fall einen Gewinn. Es ist klar, dass das Handelsergebnis von der spezifischen Marktsituation und unseren Handlungen abhängt.

Schlussfolgerung

Wir haben die praktische Implementierung eines EAs betrachtet, der eine gegebene Optionskonstruktion emuliert. Wir haben überprüft, dass die Praxis den theoretischen Prinzipien entspricht, die im ersten Artikel dieser Serie vorgestellt wurden. Im nächsten Artikel werden wir uns mit der Implementierung von Optionsstrategien befassen, die einen echten praktischen Wert haben. Sie werden von professionellen Optionshändlern verwendet.