Trading Options Without Options (Part 2): Use in Real Trading

Introduction

In the first part of the series, we briefly described the option trading instrument, its capabilities, advantages and disadvantages. We developed a theory and practical implementation in MQL5 of a method for emulating an option using an underlying asset. It is time to try options in action in actual market trading. 

To this end, we need to create an EA that will map option emulation levels into real orders and positions on the underlying asset and continuously rebalance the resulting total position.

Use in real trading

First, let's look at what strategies can be used in trading. Here we only consider speculative strategies. Let's start with the simplest ones - buying/selling single options. To do this, we will create a table with all possible options.

Simple trading strategies and conditions for their use

Long Call

• Idea: buying a call option 
• Condition: if there is confidence in the underlying asset price rise
• Profit: unlimited
• Risk: premium paid for the option (absent in emulation)

Long Put

• Idea: buying a put option in anticipation of a decline in the price of the underlying asset
• Condition: if there is confidence in the underlying asset price fall
• Profit: unlimited
• Risk: premium paid for the option (absent in emulation)

Short Call

• Idea: selling a call option in the expectation that the price of the underlying asset will not rise, but will not necessarily fall either.
• Condition: if there is confidence in the underlying asset lack of growth
• Profit: the premium paid by the option buyer (which does not exist in the emulation model)
• Risk: Unlimited

Short Put

• Idea: Selling a put option in the expectation that the price of the underlying asset will not fall, but does not necessarily have to rise.
• Condition: if there is confidence in the underlying asset lack of fall
• Profit: the premium paid by the option buyer (which does not exist in the emulation model)
• Risk: unlimited

Note:

• Selling emulated single options does not make much sense since there is no premium for it. But to further create option constructions (in stock market terms - option portfolios), all options should be implemented.
• When purchasing emulated single options, naturally, no premium is paid. But when rebalancing a portfolio, some loss may "accumulate" (it can be considered the equivalent of paying a premium). Its size depends on the specific change in the price of the underlying asset and the time the position is held. In general, this loss is comparable to the premium.

We are developing an EA to implement a trading strategy.

The TOptionBase base class and OptionLongCall option classes, OptionLongPut, OptionShortCall, OptionShortPut remain unchanged (see the previous article of the series). Now let's add a base class for an option construction, which will later allow us to create option constructions of any complexity.

This TOptionConstructionBase class is shown below. We inherited it from the CList standard class, which is part of the MQL5 libraries. In order to access CList, we need to add the following string to the beginning:

#include    <Arrays\List.mqh>

This will allow us to manipulate the lists of options to obtain the desired summary portfolio characteristics. So, let's have a look at the option construction class:

// =====================================================================
//  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;
};
// ---------------------------------------------------------------------

Let's take a closer look at it. As we can see, at the very bottom of the presented code there is a declaration of the CreateOptionConstruction abstract method, therefore the base class itself is abstract. This method is responsible for creating the option construction and will be defined in descendant classes. The method takes parameters _k, _s and _digits. The first two are the values of K and S in the sigmoid that emulates the option. The last one is the number of decimal places in the underlying asset.

Also, we have implemented an enumeration for the ENUM_OPTION_CONSTRUCTION option construction type. At this stage, it looks like this:

// ---------------------------------------------------------------------
//  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 the future, we will add more complex constructions and new types to the enumeration. This type is passed as a parameter to the class constructor when creating an object.

The SetOptionConstructionRange method (const double& _strike[], const double& _norm_price[]) allows setting the delta normalization range for the central strike for each of the options included in the construction. The parameters of strike values and normalization ranges are passed as references to arrays containing the corresponding values. The dimensions of the arrays should be equal to the number of options in the option construction.

For the above constructions, the dimension is always equal to one. In this test presentation, the dimensionality check is not performed, but it can be easily added in the working version for real trading. Since the option construction is initially specified, the dimensions of the arrays (in fact, the number of options) are known in advance.

Also, the base class defines the UpdateOptionConstructionDelta method (const double _price) for updating the total delta of the option construction, which returns the calculated total delta. The input parameter of the method is the price of the underlying asset. This method uses CList class methods to iterate over all elements of the list.

Next, we inherit real option constructions from the base class. Since all functionality is contained in the base class, the derived classes have a fairly simple 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));
  }
};

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

All that needs to be done in the descendant class is to define the CreateOptionConstruction option construction method. In this method, we create an object of the option (or group of options) we need and add the created object to the list by calling the CList::Add method.

These classes are located in the OptionEmulatorA2.mqh file attached to the article.

Trader inputs

Now let's move on to implementing the actual EA for emulation using real position management. First, let's add an enumeration that will define the overall (general) state of the EA or the trading state:

// ---------------------------------------------------------------------
//  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 the initial version of the EA, only two states will be used: trading stopped and trading in progress. Trading starts when the EA is launched after its initialization, and stops after the expiration time is reached. We will use daily options with mandatory expiration before the start of a new day. 

Add the necessary external parameters to the EA:

// =====================================================================
//  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
// ---------------------------------------------------------------------

External parameters that may raise questions:

• BaseMagic — the base value of the "magic" number (when opening a position, the option emulation level number, multiplied by 100, is added to it);
• MinLotsMultiplier — minimum lot multiplier when determining the position volume at each level;
• AddNewFromHours — start of the EA’s work within the day, in hours (from 0 to 23 hours);
• AddNewToHours — completion of the EA’s work within a day, in hours (from 1 to 24 hours);
• ExpirationTimeHours — expiration time of the option construction within a day, in hours from 1 to 24 hours;
• ExpirationTimeMinutes — expiration time of the option construction within a day, in minutes from 0 to 59 minutes;
• ForceAutoExpirationTime — time of EA unconditional expiration and stop in the "hh:mm" format;
• ADRDaysNumber — number of days to calculate historical HV volatility.

Trading EA

The following functions of the trading EA are of interest:

//---------------------------------------------------------------------
//    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);
}

Lot normalization is required because in real trading, instruments have discrete changes in trading volume. In addition, the number of digits in the volume representation and the minimum/maximum volume values are limited. All these requirements are taken into account in the NormalizeLots function presented above.

// ---------------------------------------------------------------------
//    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);
}
// ---------------------------------------------------------------------

Here the values of global variables obtained during initialization are used:

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);

The EA's algorithm is based on handling each new tick in OnTick. A simplified handler structure is shown below:

//    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;      }
    }
  }
}

Track the change in the option emulation level by calling the UpdateOptionLevel method. If the level has changed, then this method returns 'true'. Here we compare the current and previous (on the previous tick) values of the option emulation levels.

If it is necessary to rebalance positions, check whether the option emulation level has increased or decreased. If it has increased, then adding positions is required. If it has decreased, then some positions need to be closed. If the emulation level becomes zero, we close all open positions. In this way, a rebalancing of the overall position occurs.

Note that we take the average between Bid and Ask as the price for calculating the current delta of the option construction. This helps reduce the dependence of delta changes on spread changes. The EA's full text can be found in the files attached to this article.

Market orders are used when opening and closing positions. This is done to simplify the verification of the EA's work (there is a guarantee that the order will be executed). In the future, it is recommended (and is to be implemented) to switch to limit orders for opening positions. This will reduce commission costs and improve trading results by eliminating the spread when entering trades.

Testing emulation and trading in real time

Let's assume that we have decided that the EURUSD price will move predominantly upwards during the day. Let's set the type of option construction to OptionConstruction = ENUM_OPTION_CONSTRUCTION_RISING. Example of an EA simulating the Base Active Rising - Long CALL option construction is shown in the figures below: Fig. 1 — from the start of the day, Fig. 2 — enlarged trading area. Emulation levels 1 through 9 were triggered. Rebalancing of levels was carried out at the beginning of the EA's operation:

Fig. 1. Base Active Rising - Long CALL option construction in action — overview

Fig. 2. Base Active Rising - Long CALL option construction in action (zoomed in)

Fig. 3. Current state of positions during the emulation of the Base Active Rising - Long CALL option construction

 

Fig. 4. The result of rebalancing during the emulation of the Base Active Rising - Long CALL option construction in the form of trades from the trading history

Now let's assume that the next day we decide that the price will reverse and go down. Set the type of the OptionConstruction option construction = ENUM_OPTION_CONSTRUCTION_FALLING. This time, luck was not on our side - the price turned against us by the end of the day and we suffered some losses. Fig. 5 shows the development of a given option construction. Emulation levels from 1st to 5th were opened. The recorded loss due to rebalancing was USD -5.77 (see Fig. 6).

Fig. 5. Base Active Rising - Long Put option construction in action — overview

Fig. 6. The result of rebalancing during the emulation of the Base Active Rising - Long Put option construction in the form of trades from the trading history

The maximum total volume of positions can reach the value of 0.1 = 10 levels * 0.01 - this is the target volume of the option construction with the minimum lot multiplier value equal to one. As can be seen from Fig. 4, we received a fixed loss of USD -2.39 in the first case and USD -5.77 in the second as a result of rebalancing the option construction (see Fig .6). This is analogous to the premium paid for purchasing an option. As specified in the EA's parameter ForceAutoExpirationTime = "23:50", at 23:50, the option construction expired, locking in a profit in the first case. It is clear that the trading result depends on the specific market situation and our actions.

Conclusion

We have considered the practical implementation of an EA that emulates a given option construction. We have verified that the practice corresponds to the theoretical principles presented in the first article of this series. In the next article, we will look at the implementation of options strategies that have real practical value. They are used by professional options traders.