MQLmagazine.com » MQL programming

Guidelines for writing portfolio expert advisors in MQL5

Bogdan Caramalac, MQLmagazine sr.editor — Mon, 24 May 2010 21:29:43 +0000

[Versiunea romaneasca] [MQLmagazine.com in romana] [English edition]

Portfolio expert advisors, as well as the more complex multiasset expert advisors, were awaited by the retail trading community ever since limitations of the MT4 backtester became obvious, that is, about 4 – 5 years ago. The difference between multiasset and portfolio EAs is that multiasset EAs have an integrated strategy where each asset is a component, whether portfolio EAs replicate same strategy, with just some parameter differences, over more instruments. Of course, in the MT4 context, normal EAs could have been run on separate instruments and obtain portfolio effects, however backtesting could never have covered these portfolio effects because it was not possible to backtest on more than one instrument.

The main advantage of portfolying is the yield averaging while spreading the risk. The degree up to which this happens, is dependant on the overall portfolio correlation. The lesser overall correlated, the lesser nonsysthematic risk left uncovered. However, if you don’t pick the portfolio right, instead to balance your overall trading system, it will add extra instability.

A portfolio trading system must be able to:
- apply similar trading logics to a large number of assets;
- differentiate trading logics from one instrument to another;
- control exposure.

It requires a pretty large data structure to take make things manageable.

For instance, this one:

input double MarginUsagePerPosition=0.5;
 
int SymbolsCount;
 
struct IndicatorHandlersStruct
  {
   //...
  };
 
struct SystemParametersStruct
  {
   //...
  };
 
struct SymbolData
  {
    string Symbol;
    IndicatorHandlersStruct IndicatorHandlers;
    SystemParametersStruct SystemParameters;
  };
 
SymbolData SymbolsTable[300];

The first variable, MarginUsagePerPosition is a sort of asset allocation parameter, by controlling the maximal volume of each position. SymbolsCount tells how many symbols are used and it can be used for enumeration, while the big SymbolsTable[] will contain all the needed data, from symbols to handlers. For instance, the following structure will be set up to calculate 4 moving averages (two on M5 and two on H1) per each symbol:

struct IndicatorHandlersStruct
  {
   int MovingAveragesHandlers14[2];
   int MovingAveragesHandlers9[2];
  };
 
struct SymbolData
  {
    string Symbol;
    IndicatorHandlersStruct IndicatorHandlers;
    datetime LastBarTime;
  };
 
SymbolData SymbolsTable[300];

Before OnInit() we have to write a procedure to fill in the SymbolsTable[] with the indicator handlers. MakeIndicatorHandlers() is being called from OnInit() to separate the symbols setup from the indicators setup. While you can easily alter OnInit() to change the list, by adding, deleting or making an automated instrument selector, the MakeIndicatorHandlers() will remain static, with the purpose to fill the structure with the needed indicator handlers.

void MakeIndicatorHandlers()
  {
   datetime lastbar[1];
   for (int i=0;i<SymbolsCount;i++)
      {
       SymbolsTable[i].IndicatorHandlers.MovingAverageHandlers14[0]=iTEMA(SymbolsTable[i].Symbol,PERIOD_M5,14,0,PRICE_OPEN);
       SymbolsTable[i].IndicatorHandlers.MovingAverageHandlers9[0]=iTEMA(SymbolsTable[i].Symbol,PERIOD_M5,9,0,PRICE_OPEN);
       SymbolsTable[i].IndicatorHandlers.MovingAverageHandlers14[1]=iTEMA(SymbolsTable[i].Symbol,PERIOD_H1,14,0,PRICE_OPEN);
       SymbolsTable[i].IndicatorHandlers.MovingAverageHandlers9[1]=iTEMA(SymbolsTable[i].Symbol,PERIOD_H1,9,0,PRICE_OPEN);  
      }
   return;
  }

Within OnInit(), we set up the symbols table. For instance, we are making it to work on 3 forex pairs: EURUSD, USDCHF, GBPJPY:

int OnInit()
  {
   SymbolsTable[0].Symbol="EURUSD";
   SymbolsTable[1].Symbol="USDCHF";
   SymbolsTable[2].Symbol="GBPJPY";
   SymbolsCount=3;
   MakeIndicatorHandlers();
   return(0);
  }

And now OnTick():

void OnTick()
  {
   datetime datetime_array[1];
   for (int i=0;i<SymbolsCount;i++)
      {
       CopyTime(SymbolsTable[i].Symbol,PERIOD_M5,0,1,datetime_array);
       if (datetime_array[0]!=SymbolsTable[i].LastBarTime)
         {               
          TradeLogics(i);
          LastBarTime[i]=datetime_array[0];    
         }//if (datetime_array[0]!=SymbolsTable[i].LastBarTime)
      }//for (int i=0;i
   return;
  }

Now all the pieces are complete. OnTick() will check for each instrument if a new bar appeared and will call TradeLogics() for every instrument in the array, which will implement decision and trading.

We will not stop on TradeLogics() in this article, because TradeLogics() is EA specific. But a few principles should be guides while writing the TradeLogics(). The first division of the TradeLogics() is the asset class that it deals with. It can’t deal with equities the same way it deals with forex. Equities don’t run 24 hours a day 5 days a week. They have specific trading sessions and gaps from a day to another, not mentioning from a week to another. So this is the first division, the asset class. The second, is that it is better to separate the trading functions from the TradeLogics(). For instance, the TradeLogics() could just command how to adjust the position on a given instrument, and leave the trading function to a ManagePosition() procedure.
Of course, TradeLogics() can be in practice triggered by OnTrade() or OnChartEvent(), or even a CEP engine’s EventsCallback().

double UnitsToLots(double units,string symbol)
  {
  double dlotsize=SymbolInfoDouble(symbol,SYMBOL_TRADE_CONTRACT_SIZE);
  double mag=SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP);
  double mini=SymbolInfoDouble(symbol,SYMBOL_VOLUME_MIN);
  double big=1/mag;    
  double size=dlotsize/big;
  double dlots0,dlots1,back0,back1;
  dlots0=NormalizeDouble(units/size,0)*mag;
  dlots1=dlots0+mag;
  back0=dlots0*big*size;
  back1=dlots1*big*size;
  if (back1-units<units-back0)
    {
     if (dlots1<mini)
       return(mini);  
     else  
       return(dlots1);
    }
  else
    {
     if (dlots0==0)
        return(mini);
     else
       {
        if (dlots0<mini)
          return(mini);
        else
          return(dlots0);
       }//else if (dlots0==0)
    }//else if if (back1-units
  }

UnitsToLots() is a port of a function that I wrote in MQL4 times, and it was working at that time with MarketInfo(). UnitsToLots() will return the appropriate number of lots correspondant to a volume given in units. For instance it may answer 1.0 for 100000 units of EURUSD.

#define FLAT        0
#define LONG        1
#define SHORT       2
 
int GetPositionType(int asset_index)
  {
   string symbol=SymbolsTable[asset_index].Symbol;
   bool sel=PositionSelect(symbol);
   if (sel==false)
     return(FLAT);
   else
    {
     long p=PositionGetInteger(POSITION_TYPE);
     if (p==POSITION_TYPE_BUY)
       return(LONG);
     else
       return(SHORT);
    }
  }

This function is a simple proxy to get a straight position type value. The value for POSITION_TYPE_BUY is 0 in MQL5, and PositionInfoInteger() will answer 0 even if the position was not previously selected.

void ManagePosition(int asset_index,int operation,double forcevolume=0.00)
  {   
   MqlTradeRequest request;
   MqlTradeResult result;
   int p=GetPositionType(asset_index);
   double now_volume;
   double current_volume,v0;
   if (PositionSelect(SymbolsTable[asset_index].Symbol)==true)
     current_volume=PositionGetDouble(POSITION_VOLUME);
   else
     current_volume=0;
   v0=current_volume;   
   request.action=TRADE_ACTION_DEAL;
   request.symbol=SymbolsTable[asset_index].Symbol; 
   request.deviation=Slippage;
   request.type_filling=ORDER_FILLING_AON;
   request.type_time=ORDER_TIME_GTC;
   if (p==FLAT)
     {
      if (DoubleToString(forcevolume,2)=="0.00")
        request.volume=UnitsToLots( (MarginUsagePerPosition/100)*AccountInfoDouble(ACCOUNT_EQUITY)*AccountInfoInteger(ACCOUNT_LEVERAGE),SymbolsTable[asset_index].Symbol );
      else
        request.volume=forcevolume;
      if (operation==LONG)
        {
         request.type=ORDER_TYPE_BUY;
         request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_ASK),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));
        }
      if (operation==SHORT)
        {
         request.type=ORDER_TYPE_SELL;
         request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_BID),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));
        }
      if (operation==FLAT)
        return;
     }
   else//if (p==FLAT)
     {     
      if (p==LONG&&operation==SHORT)
        {
         if (DoubleToString(forcevolume,2)=="0.00")
           request.volume=current_volume+UnitsToLots( (MarginUsagePerPosition/100)*AccountInfoDouble(ACCOUNT_EQUITY)*AccountInfoInteger(ACCOUNT_LEVERAGE),SymbolsTable[asset_index].Symbol );
         else
           request.volume=current_volume+forcevolume;
         request.type=ORDER_TYPE_SELL;         
         request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_BID),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));         
        }
      if (p==SHORT&&operation==LONG)
        {
         if (DoubleToString(forcevolume,2)=="0.00")         
           request.volume=current_volume+UnitsToLots( (MarginUsagePerPosition/100)*AccountInfoDouble(ACCOUNT_EQUITY)*AccountInfoInteger(ACCOUNT_LEVERAGE),SymbolsTable[asset_index].Symbol );
         else
           request.volume=current_volume+forcevolume;
         request.type=ORDER_TYPE_BUY;
         request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_ASK),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));
        }
      if (p==LONG&&operation==FLAT)
        {       
         if (DoubleToString(forcevolume,2)=="0.00")
           request.volume=current_volume;
         else
           request.volume=forcevolume;
         request.type=ORDER_TYPE_SELL;         
         request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_BID),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));         
        }
      if (p==SHORT&&operation==FLAT)
        {
         if (DoubleToString(forcevolume,2)=="0.00")           
           request.volume=current_volume;
         else
           request.volume=forcevolume;
         request.type=ORDER_TYPE_BUY;         
         request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_ASK),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));         
        } 
      if (p==LONG&&operation==LONG)//adjustment of the present LONG position
        {
         if (DoubleToString(forcevolume,2)=="0.00")
           request.volume=UnitsToLots( (MarginUsagePerPosition/100)*AccountInfoDouble(ACCOUNT_EQUITY)*AccountInfoInteger(ACCOUNT_LEVERAGE),SymbolsTable[asset_index].Symbol )-current_volume;
         else
           request.volume=forcevolume-current_volume;
         if (NormalizeDouble(request.volume,2)>0.00)
           {         
            request.type=ORDER_TYPE_BUY;
            request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_ASK),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));
           }
         else //we close the difference
           {
            request.volume=MathAbs(request.volume);
            request.type=ORDER_TYPE_SELL;         
            request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_BID),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));         
           }
        }        
      if (p==SHORT&&operation==SHORT)//adjustment of the present SHORT position
        {
         if (DoubleToString(forcevolume,2)=="0.00")
           request.volume=UnitsToLots( (MarginUsagePerPosition/100)*AccountInfoDouble(ACCOUNT_EQUITY)*AccountInfoInteger(ACCOUNT_LEVERAGE),SymbolsTable[asset_index].Symbol )-current_volume;
         else
           request.volume=forcevolume-current_volume;
         if (NormalizeDouble(request.volume,2)>0.00)
           {
            request.type=ORDER_TYPE_SELL;         
            request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_BID),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));                  
           }
         else
           {
            request.volume=MathAbs(request.volume);
            request.type=ORDER_TYPE_BUY;
            request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_ASK),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));            
           }
        }        
     }//if (p==FLAT)]  
   if (DoubleToString(request.volume,2)!="0.00")
     {
      OrderSend(request,result);     
      PositionSetSLTP(StopLoss,TakeProfit);
     }     
  }

What does ManagePosition() do ? It opens a position on the given asset by index, upon request, if it is flattened before ; or it reverts the current position, by recalculating the new lot size (calculates new lot size with the formula, adds to current volume and reverses operation). It can also add or cut from the current position. The forcevolume parameter can be used to force a given volume into a trade, bypassing calculus.
How about setting a stop loss ? Nothing easier:

void PositionSetSLTP(int asset_index,int sl,int tp)
  {
   bool todosl, todotp;
   MqlTradeRequest request;
   MqlTradeResult result;   
   double price=0.00;
   int p=GetPositionType(asset_index);
   if (p==LONG||p==SHORT)
     price=PositionGetDouble(POSITION_PRICE_OPEN);
   request.action=TRADE_ACTION_SLTP;
   request.symbol=SymbolsTable[asset_index].Symbol;   
   todosl=false;
   todotp=false;
   if (DoubleToString(sl,4)!="0.0000")
     {
      todosl=true;      
      if (p==LONG)
        request.sl=NormalizeDouble(price-sl*SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_POINT),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));
      if (p==SHORT)
        request.sl=NormalizeDouble(price+sl*SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_POINT),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));
     }
   if (DoubleToString(tp,4)!="0.0000")
     {      
      todotp=true;
      if (p==LONG)
        request.tp=NormalizeDouble(price+tp*SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_POINT),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));
      if (p==SHORT)
        request.tp=NormalizeDouble(price-tp*SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_POINT),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));
     }
   request.deviation=Slippage;   
   if (todosl==true||todotp==true)
     OrderSend(request,result);
  }

Note that the OrderSend() calls are not followed by an analysis of the result. We didn’t dwelve into retcodes because some of them are not completely clear to us.

And finally OnDeinit(), which destroys the indicator handlers.

void OnDeinit(const int reason)
  {
   for (int i=0;i<SymbolsCount;i++)
      {   
       IndicatorRelease(SymbolsTable[i].IndicatorHandlers.MovingAverageHandlers14[0]);
       IndicatorRelease(SymbolsTable[i].IndicatorHandlers.MovingAverageHandlers9[0]);
       IndicatorRelease(SymbolsTable[i].IndicatorHandlers.MovingAverageHandlers14[1]);
       IndicatorRelease(SymbolsTable[i].IndicatorHandlers.MovingAverageHandlers9[1]);
      }
   return;
  }

MQL5 : A portfolio moving average sample expert

Bogdan Caramalac, MQLmagazine sr.editor — Mon, 24 May 2010 21:29:26 +0000

[Versiunea romaneasca] [MQLmagazine.com in romana] [English edition]

I wrote this expert advisor to as a full demonstration on writing portfolio expert advisors, following the principles presented in Guidelines for writing portfolio expert advisors in MQL5.

The expert will work on the chosen timeframe, only when a new bar forms up on every participating instrument. Upon checking moving average intersections, it will manage positions. There is also the option to filter by volatility (I repaired the BBoverSTD indicator from the Volatility analysis : bridging the gap from volatility forecasting to price forecasting article).

//+------------------------------------------------------------------+
//|                                                  PortfolioMA.mq5 |
//|                                       Copyright Bogdan Caramalac |
//|                                           http://mqlmagazine.com |
//+------------------------------------------------------------------+
#property copyright "Copyright Bogdan Caramalac"
#property link      "http://mqlmagazine.com"
#property version   "1.00"
 
#define FLAT        0
#define LONG        1
#define SHORT       2
 
input int Slippage=30;
input double MarginUsagePerPosition=0.5;
input bool VolatilityFilter=false;
input int StopLoss=300;
input int TakeProfit=1000;
 
input int SlowMALength=14;
input int FastMALength=9;

This section defines the constants for working with positions (FLAT,LONG,SHORT) and the parameters of the system.

int SymbolsCount;
 
struct IndicatorHandlersStruct
  {
   int SlowMovingAverageHandler;
   int FastMovingAverageHandler;
   int BBoverSTDHandler;
  };
 
struct SymbolData
  {
    string Symbol;
    IndicatorHandlersStruct IndicatorHandlers;
    datetime LastBarTime;    
  };
 
SymbolData SymbolsTable[30];

This section defines the data structure holding the symbols and indicator handlers.

void MakeIndicatorHandlers()
  {
   datetime datetime_array[1];
   int error1,error2,error3;
   for (int i=0;i<SymbolsCount;i++)
      {
       error1=0;
       error2=0;
       error3=0;
       SymbolsTable[i].IndicatorHandlers.SlowMovingAverageHandler=iMA(SymbolsTable[i].Symbol,Period(),SlowMALength,0,MODE_SMA,PRICE_OPEN);
       Print("SymbolsTable[",i,"].IndicatorHandlers.SlowMovingAverageHandler=",SymbolsTable[i].IndicatorHandlers.SlowMovingAverageHandler);
       if (SymbolsTable[i].IndicatorHandlers.SlowMovingAverageHandler<0)
         { 
          Print("Invalid handle.");
          error1=GetLastError();
          Print("Error ",error1," while initializing iMA(",SlowMALength,") for ",SymbolsTable[i].Symbol);
         }
       SymbolsTable[i].IndicatorHandlers.FastMovingAverageHandler=iMA(SymbolsTable[i].Symbol,Period(),FastMALength,0,MODE_SMA,PRICE_OPEN);
       Print("SymbolsTable[",i,"].IndicatorHandlers.FastMovingAverageHandler=",SymbolsTable[i].IndicatorHandlers.FastMovingAverageHandler);
       if (SymbolsTable[i].IndicatorHandlers.FastMovingAverageHandler<0)
         {
          Print("Invalid handle.");
          error2=GetLastError();
          Print("Error ",error2," while initializing iMA(",FastMALength,") for ",SymbolsTable[i].Symbol);
         }
       SymbolsTable[i].IndicatorHandlers.BBoverSTDHandler=iCustom(SymbolsTable[i].Symbol,Period(),"BBoverSTD",20,10,1.5,"SMA",2,0);
       Print("SymbolsTable[",i,"].IndicatorHandlers.BBoverSTDHandler=",SymbolsTable[i].IndicatorHandlers.BBoverSTDHandler);
       if (SymbolsTable[i].IndicatorHandlers.BBoverSTDHandler<0)
         { 
          Print("Invalid handle.");
          error3=GetLastError();
          Print("Error ",error3," while initializing BBoverSTD for ",SymbolsTable[i].Symbol);
         }                   
      }
   return;
  }

This is the MakeIndicatorHandlers() routine tailored for this EA.

Now follow UnitsToLots(), GetPositionType(), PositionSetSLTP() and ManagePosition() that are the ones presented in the Guidelines for writing portfolio expert advisors in MQL5.

string MASignal(int asset_index)
  {
   double maslowarray[1];
   double mafastarray[1];
   double mafast,maslow;
   datetime t;
   int copycount1,copycount2;
   int error1=0;
   int error2=0;
   string signal;
   copycount1=CopyBuffer(SymbolsTable[asset_index].IndicatorHandlers.SlowMovingAverageHandler,0,0,1,maslowarray);
   if (copycount1==-1)
     {
      Print("Nothing copied (1). Retrieving error.");
      error1=GetLastError();
     }
   copycount2=CopyBuffer(SymbolsTable[asset_index].IndicatorHandlers.FastMovingAverageHandler,0,0,1,mafastarray);
   if (copycount2==-1)
     {
      Print("Nothing copied (2). Retrieving error.");
      error2=GetLastError();
     }
   maslow=NormalizeDouble(maslowarray[0],SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));
   mafast=NormalizeDouble(mafastarray[0],SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));   
   t=TimeCurrent();
   if (maslow<mafast)
     signal="L";
   if (maslow==mafast)
     signal="-";
   if (maslow>mafast)
     signal="S";
   return(signal);
  }

This returns the moving average signal for the requested asset. Signal can be “L”, “S” or “-” .

void TradeLogics(int asset_index)
  {
   string s;
   double stddev[1];
   double bbhi[1];
   double bblo[1];
   int copycount;
   s=MASignal(asset_index);   
   if (VolatilityFilter==true)
     {
      copycount=CopyBuffer(SymbolsTable[asset_index].IndicatorHandlers.BBoverSTDHandler,0,0,1,stddev);
      copycount=CopyBuffer(SymbolsTable[asset_index].IndicatorHandlers.BBoverSTDHandler,2,0,1,bbhi);
     }
   if (GetPositionType(asset_index)==FLAT)
     {      
      if (s=="L")
        {
         if (VolatilityFilter==true)
           {
            if (stddev[0]>bbhi[0])
              ManagePosition(asset_index,LONG);
           }
         else
           ManagePosition(asset_index,LONG);
        }
      if (s=="S")
        {
         if (VolatilityFilter==true)
           {
            if (stddev[0]>bbhi[0])
              ManagePosition(asset_index,SHORT);
           }
         else
           ManagePosition(asset_index,SHORT);
        }
     }//else if (GetPositionType(asset_index)==FLAT)
   else//position is not flat
     {
      if (GetPositionType(asset_index)==LONG)
        {
         if (VolatilityFilter==true)
           {
            if (s=="S"||stddev[0]<bbhi[0])
              ManagePosition(asset_index,FLAT);
           }           
         else
           {
            if (s=="S")
              ManagePosition(asset_index,FLAT);           
           }
        }
      if (GetPositionType(asset_index)==SHORT)
        {
         if (VolatilityFilter==true)
           {
            if (s=="L"||stddev[0]<bbhi[0])
              ManagePosition(asset_index,FLAT);
           }
         else
           {
            if (s=="L")
              ManagePosition(asset_index,FLAT);           
           }        
        }
     }           
   return;
  }

This is the TradeLogics(). First it checks if VolatilityFilter is enabled, and only in this case calls the BBoverSTD indicator, to save time for the situation the filter is disabled. Then it tests if position is flat.
If it is, goes long or short according to the MASignal() , eventually filtered by the BBoverSTD values, if VolatilityFilter is enabled. If the position is long or short already, it checks only for contrarian signals (of course, same filtering). If contrarian signal comes, position is flattened, otherwise there is no adaptation of position to the new equity size (although the ManagePosition() is able to do it, but not asked to do so).

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   string crtsymbol;
   SymbolsTable[0].Symbol="EURUSD";
   SymbolsTable[1].Symbol="USDJPY";
   SymbolsTable[2].Symbol="GBPUSD";
   SymbolsTable[3].Symbol="USDCHF";
   SymbolsCount=1;
   MakeIndicatorHandlers();
   return(0);
  }

This is the OnInit(). It is already preset to work with four currency pairs. If SymbolsCount remains 1 , only EURUSD will be traded. If you set it to 4, all four pairs will be traded. You can alter the SymbolsTable[] however you wish (problems may arise however at the lot calculus while trading CFDs). OnInit() must end with a call to MakeIndicatorHandlers() to get the indicator handlers ready for usage.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   datetime datetime_array[1];
   for (int i=0;i<SymbolsCount;i++)
      {
       CopyTime(SymbolsTable[i].Symbol,Period(),0,1,datetime_array);
       if (datetime_array[0]!=SymbolsTable[i].LastBarTime)
         {
          //Print(SymbolsTable[i].Symbol," :: ",TimeToString(SymbolsTable[i].LastBarTime,TIME_DATE)," ",TimeToString(SymbolsTable[i].LastBarTime,TIME_MINUTES),"  vs. ",TimeToString(datetime_array[0],TIME_DATE)," ",TimeToString(datetime_array[0],TIME_SECONDS) );
          TradeLogics(i);
          SymbolsTable[i].LastBarTime=datetime_array[0];          
         }//if (datetime_array[0]!=LastBarOccurred[i])
      }//for (int i=0;i
   return;
  }

This is the OnTick(). The OnTick() contains the symbol loop, and requires the time of the last bar of the given timeframe on the current symbol given by the cycle. If this time is different than remembered time, it means a new bar appeared on that symbol chart. Then TradeLogics() is called for decision and subsequent call to ManagePosition().

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   for (int i=0;i<SymbolsCount;i++)
      {   
       IndicatorRelease(SymbolsTable[i].IndicatorHandlers.SlowMovingAverageHandler);
       IndicatorRelease(SymbolsTable[i].IndicatorHandlers.FastMovingAverageHandler);
       IndicatorRelease(SymbolsTable[i].IndicatorHandlers.BBoverSTDHandler);
      }
   return;
  }

This is the OnDeinit(). It releases indicator handlers. Should OnInit() be run again, it will make other handlers. It is not completely necessary to do this, however wasting memory with new handlers every time OnInit() runs is not clean programming.

The following backtests were made with no StopLoss and TakeProfit set, also with VolatilityFilter disabled.

As we can see, portfolying was not a good choice. It added extra instability and deeper drawdowns. However, now we are dealing with trading systems, while portfolio management theory supposes a generally long or out strategy. This why, in financial theory, negative correlations would drive risks down, because pluses on some assets would compensate with minuses on other assets. But, what we have now is a portfolio of trading systems. We can think a trading system as an equity function of instruments:

 equity = trading system (instrument)

On two perfectly negatively correlated assets, the trading system function would output two positively correlated equity series. A rigorous approach would ask that a Markowitz or CAPM selection over trading systems to be done with based on trading system outputs rather than market data.

See also the article about trading systems virtualization article, which is analysing the problem from another point of view.

File link:
PortfolioMA.mq5

Trading systems virtualization to achieve equity line fitting – a myth ?

Bogdan Caramalac, MQLmagazine sr.editor — Mon, 24 May 2010 21:29:07 +0000

[Versiunea romaneasca] [MQLmagazine.com in romana] [English edition]

Did you ever think that you’d like to have a moving average over the equity of a trading system, so you can turn it on and off ? This would be called equity line fitting.

The frustrating aspect is that once you start doing this from the trading system that you want to curve it its equity line, you cannot control the process anymore, as the indicators of the equity line will report differently once you hit the switch.

So, what you have to do is to let the system paper trade somehow in parallel to your main trading system, and copy the trades in your main trading system when the switch is on, ignore paper trades when the switch is off.

This can be done by virtualization. Meaningly, you have to write a paper trade position management system, like a virtual account and output its “equity” to the main trading system, which will curve-fit this equity and decide whether to replicate or not the paper system’s trades.

Thus, we begin writing such a system, in file which we’ll call TradeVirtualization.mqh .

//+------------------------------------------------------------------+
//|                                          TradeVirtualization.mqh |
//|                                       Copyright Bogdan Caramalac |
//|                                           http://mqlmagazine.com |
//+------------------------------------------------------------------+
#property copyright "Copyright Bogdan Caramalac"
#property link      "http://mqlmagazine.com"
#property version "1.0"
 
#define FLAT        0
#define LONG        1
#define SHORT       2
 
struct VirtualSymbolData
  {
    string Symbol;    
    double position;
    double price;
    double sl;
    double tp;
    double marked_price;    
  };
 
struct VirtualEquityData
  {
   datetime opentime,closetime;
   double open,high,low,close;  
  };

We begin with the regular defines for position management, followed by two structures. The first is intended to store symbol data in, providing symbol, position (positive – long, negative – short), price (price of initiation for the position), marked price (last price at which the position was marked to market). The second is the intended to store virtual equity data : open and close times of an equity bar ; open, high, low, close for the equity within interval. Now it’s time for the VirtualAccount class.

class VirtualAccount
  {   
   public:
   int VirtualSymbolsCount;    
   VirtualSymbolData VirtualSymbolsTable[30]; 
   VirtualEquityData VirtualEquity[500];
   double VirtualLastAccountEquity;  
   int VirtualLastEquityPos;
   uint VirtualEquityBarSpan;
 
   void VirtualAccountSet(double Equity,uint TimeSpan)   
       {
        datetime tc=TimeCurrent();
        VirtualEquity[0].opentime=tc;
        VirtualEquity[0].open=Equity;
        VirtualEquity[0].high=Equity;
        VirtualEquity[0].low=Equity;
        VirtualEquity[0].close=Equity;
        VirtualEquity[0].closetime=tc;
        VirtualLastAccountEquity=VirtualEquity[0].close;
        VirtualEquityBarSpan=TimeSpan;
        VirtualLastEquityPos=0;
        return;
       }  
 
    int VirtualGetPositionType(int asset_index); 
    double VirtualGetPositionSize(int asset_index);
    void VirtualPositionSetSL(double asset_index,double sl);
    void VirtualPositionSetTP(double asset_index,double tp);
    void VirtualMarkToMarket(int asset_index);
    void VirtualChangePosition(int asset_index,int direction,double price,double lotsize);
    private:
    void VirtualAddNewEquity(double equity);
 
    public:
    VirtualAccount() 
       {
        VirtualAccountSet(AccountInfoDouble(ACCOUNT_EQUITY),0);
       };      
  };

The class contains an array of VirtualSymbolsData and its count, and an array with VirtualEquityData. Other key parameters are VirtualLastEquityPos and VirtualEquityBarSpan (the time interval of a bar, in seconds). VirtualLastAccountEquity is just a proxy for retrieving last recorded equity.

int VirtualAccount::VirtualGetPositionType(int asset_index)     
   {
    if (DoubleToString(NormalizeDouble(VirtualSymbolsTable[asset_index].position,2),2)=="0.00")
      return(FLAT);
    if (VirtualSymbolsTable[asset_index].position>0.00)
      return(LONG);
    if (VirtualSymbolsTable[asset_index].position<0.00)
      return(SHORT); 
    return(0);       
   }
 
double VirtualAccount::VirtualGetPositionSize(int asset_index)     
   {
    if (DoubleToString(NormalizeDouble(VirtualSymbolsTable[asset_index].position,2),2)=="0.00")
      return(0.00);
    return(NormalizeDouble(MathAbs(VirtualSymbolsTable[asset_index].position),2));       
   }       
 
 void VirtualAccount::VirtualPositionSetSL(double asset_index,double sl)
     {
      VirtualSymbolsTable[asset_index].sl=sl;
     }
 
 void VirtualAccount::VirtualPositionSetTP(double asset_index,double tp)
     {
      VirtualSymbolsTable[asset_index].tp=tp;
     }

VirtualGetPositionType() and VirtualGetPositionSize() are pure informational. The position size is always positive, like the POSITION_VOLUME requests to MQL5’s PositionInfoDouble(). The other two functions do what their name says they do.

void VirtualAccount::VirtualAddNewEquity(double equity)
    {
     datetime tc=TimeCurrent();
     uint diff;
     diff=tc-VirtualEquity[VirtualLastEquityPos].opentime;
     if (diff<=VirtualEquityBarSpan)
       {
        if (VirtualEquity[VirtualLastEquityPos].high<equity)
          VirtualEquity[VirtualLastEquityPos].high=equity;
        if (VirtualEquity[VirtualLastEquityPos].low>equity)
          VirtualEquity[VirtualLastEquityPos].low=equity;
        VirtualEquity[VirtualLastEquityPos].close=equity;
        diff=tc-VirtualEquity[VirtualLastEquityPos].closetime;           
        VirtualEquity[VirtualLastEquityPos].closetime=tc;           
        VirtualLastAccountEquity=equity;
        return;
       }
     if (VirtualLastEquityPos!=ArrayRange(VirtualEquity,0)-1)
       {           
        VirtualLastEquityPos++;
        VirtualEquity[VirtualLastEquityPos].opentime=tc;
        VirtualEquity[VirtualLastEquityPos].open=equity;
        VirtualEquity[VirtualLastEquityPos].high=equity;
        VirtualEquity[VirtualLastEquityPos].low=equity;
        VirtualEquity[VirtualLastEquityPos].close=equity;           
        VirtualEquity[VirtualLastEquityPos].closetime=tc;
        VirtualLastAccountEquity=equity;
        return;
       }
     else
       {
        for (int i=0;i<ArrayRange(VirtualEquity,0)-1;i++)
           VirtualEquity[i]=VirtualEquity[i+1];                  
        VirtualEquity[VirtualLastEquityPos].opentime=tc;
        VirtualEquity[VirtualLastEquityPos].open=equity;
        VirtualEquity[VirtualLastEquityPos].high=equity;
        VirtualEquity[VirtualLastEquityPos].low=equity;
        VirtualEquity[VirtualLastEquityPos].close=equity;           
        VirtualEquity[VirtualLastEquityPos].closetime=tc;
        VirtualLastAccountEquity=equity;
        return;
       }        
    }

At the beginning, the class is automatically set up with an equity equal to the account equity it runs on and a timespan of 0. The user may set the account to have a different startup equity and timespan. At every tick, VirtualMarkToMarket(-1) has to be called to ensure that all positions are marked to market with the new tick data. After each mark to market (either individual, with a positive parameter, or overall, with a negative parameter), a new equity value is calculated. Now the recording in the VirtualEquity[] begins from 0. If the timespan is not 0, and the new tick comes within the timespan from last equity bar opening time, the new tick is recorded on that bar, on the close field, stamping also the closetime field. High and low per equity bar is recalculated. If the timespan is 0, or if the new equity comes too late, it enters on the following bar, and so on, up to the maximum subscript (499). When it is to enter on 500, array is slided to the left one position and bar 499 starts to be recorded again. VirtualAddNewEquity() is called only from this class. Thus, it was designated to be a private method.

void VirtualAccount::VirtualMarkToMarket(int asset_index) //marks a new equity value
    {
     double fluctuation=0.00;
     double rprice,new_equity;
     int p;
     if (asset_index<0)//mark all
       {
        for (int i=0;i<VirtualSymbolsCount;i++)
           {
            if (DoubleToString(VirtualSymbolsTable[i].position,2)=="0.00")
              continue;
            if (NormalizeDouble(VirtualSymbolsTable[i].position,2)>0.00)
              rprice=NormalizeDouble(SymbolInfoDouble(VirtualSymbolsTable[i].Symbol,SYMBOL_BID),SymbolInfoInteger(VirtualSymbolsTable[i].Symbol,SYMBOL_DIGITS));
            if (NormalizeDouble(VirtualSymbolsTable[i].position,2)<0.00)
              rprice=NormalizeDouble(SymbolInfoDouble(VirtualSymbolsTable[i].Symbol,SYMBOL_ASK),SymbolInfoInteger(VirtualSymbolsTable[i].Symbol,SYMBOL_DIGITS));                
            fluctuation=fluctuation+MathAbs(VirtualSymbolsTable[i].position)*SymbolInfoDouble(VirtualSymbolsTable[i].Symbol,SYMBOL_TRADE_CONTRACT_SIZE)*(rprice-VirtualSymbolsTable[i].marked_price);               
            VirtualSymbolsTable[i].marked_price=rprice;
            if (DoubleToString(VirtualSymbolsTable[i].sl,5)!="0.00000")
              {
               if (VirtualSymbolsTable[i].position>0.00&&rprice<=VirtualSymbolsTable[i].sl)
                 {
                  VirtualSymbolsTable[i].position=0.00;                     
                  VirtualSymbolsTable[i].tp=0.00;
                  VirtualSymbolsTable[i].sl=0.00;
                 }
               if (VirtualSymbolsTable[i].position<0.00&&rprice>=VirtualSymbolsTable[i].sl)
                 {
                  VirtualSymbolsTable[i].position=0.00;                     
                  VirtualSymbolsTable[i].tp=0.00;
                  VirtualSymbolsTable[i].sl=0.00;
                 }                    
              }
            if (DoubleToString(VirtualSymbolsTable[i].tp,5)!="0.00000")
              {
               if (VirtualSymbolsTable[i].position>0.00&&rprice>=VirtualSymbolsTable[i].tp)
                 {
                  VirtualSymbolsTable[i].position=0.00;                     
                  VirtualSymbolsTable[i].tp=0.00;
                  VirtualSymbolsTable[i].sl=0.00;
                 }
               if (VirtualSymbolsTable[i].position<0.00&&rprice<=VirtualSymbolsTable[i].tp)
                 {
                  VirtualSymbolsTable[i].position=0.00;                     
                  VirtualSymbolsTable[i].tp=0.00;
                  VirtualSymbolsTable[i].sl=0.00;
                 }                    
              }                         
           }
        new_equity=VirtualEquity[VirtualLastEquityPos].close+fluctuation;
        VirtualAddNewEquity(new_equity);  
       }                      
     else
       {
        if (DoubleToString(VirtualSymbolsTable[asset_index].position,2)!="0.00")
          {
           if (NormalizeDouble(VirtualSymbolsTable[asset_index].position,2)>0.00)
             {
              p=LONG;
              rprice=NormalizeDouble(SymbolInfoDouble(VirtualSymbolsTable[asset_index].Symbol,SYMBOL_BID),SymbolInfoInteger(VirtualSymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));
             }
           if (NormalizeDouble(VirtualSymbolsTable[asset_index].position,2)<0.00)
             {
              p=SHORT;
              rprice=NormalizeDouble(SymbolInfoDouble(VirtualSymbolsTable[asset_index].Symbol,SYMBOL_ASK),SymbolInfoInteger(VirtualSymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));                
             }
           //if (p==LONG)
           //  Print("Market marking @ ",DoubleToString(rprice,SymbolInfoInteger(VirtualSymbolsTable[asset_index].Symbol,SYMBOL_DIGITS))," for ",VirtualSymbolsTable[asset_index].Symbol," ",DoubleToString(VirtualSymbolsTable[asset_index].position,2)," LONG @ ",DoubleToString(VirtualSymbolsTable[asset_index].price,SymbolInfoInteger(VirtualSymbolsTable[asset_index].Symbol,SYMBOL_DIGITS)),"last mark @ ",DoubleToString(VirtualSymbolsTable[asset_index].marked_price,SymbolInfoInteger(VirtualSymbolsTable[asset_index].Symbol,SYMBOL_DIGITS))," -> ",DoubleToString(new_equity,2)," by fl. ",DoubleToString(fluctuation,2));
           //if (p==SHORT)
           //  Print("Market marking @ ",DoubleToString(rprice,SymbolInfoInteger(VirtualSymbolsTable[asset_index].Symbol,SYMBOL_DIGITS))," for ",VirtualSymbolsTable[asset_index].Symbol," ",DoubleToString(VirtualSymbolsTable[asset_index].position,2)," SHORT @ ",DoubleToString(VirtualSymbolsTable[asset_index].price,SymbolInfoInteger(VirtualSymbolsTable[asset_index].Symbol,SYMBOL_DIGITS)),"last mark @ ",DoubleToString(VirtualSymbolsTable[asset_index].marked_price,SymbolInfoInteger(VirtualSymbolsTable[asset_index].Symbol,SYMBOL_DIGITS))," -> ",DoubleToString(new_equity,2)," by fl. ",DoubleToString(fluctuation,2));                
           fluctuation=fluctuation+MathAbs(VirtualSymbolsTable[asset_index].position)*SymbolInfoDouble(VirtualSymbolsTable[asset_index].Symbol,SYMBOL_TRADE_CONTRACT_SIZE)*(rprice-VirtualSymbolsTable[asset_index].marked_price);               
           VirtualSymbolsTable[asset_index].marked_price=rprice;
           if (DoubleToString(VirtualSymbolsTable[asset_index].sl,5)!="0.00000")
             {
              if (VirtualSymbolsTable[asset_index].position>0.00&&rprice<=VirtualSymbolsTable[asset_index].sl)
                {
                 VirtualSymbolsTable[asset_index].position=0.00;                     
                 VirtualSymbolsTable[asset_index].tp=0.00;
                 VirtualSymbolsTable[asset_index].sl=0.00;
                }
              if (VirtualSymbolsTable[asset_index].position<0.00&&rprice>=VirtualSymbolsTable[asset_index].sl)
                {
                 VirtualSymbolsTable[asset_index].position=0.00;                     
                 VirtualSymbolsTable[asset_index].tp=0.00;
                 VirtualSymbolsTable[asset_index].sl=0.00;
                }                    
             }
           if (DoubleToString(VirtualSymbolsTable[asset_index].tp,5)!="0.00000")
             {
              if (VirtualSymbolsTable[asset_index].position>0.00&&rprice>=VirtualSymbolsTable[asset_index].tp)
                {
                 VirtualSymbolsTable[asset_index].position=0.00;                     
                 VirtualSymbolsTable[asset_index].tp=0.00;
                 VirtualSymbolsTable[asset_index].sl=0.00;
                }
              if (VirtualSymbolsTable[asset_index].position<0.00&&rprice<=VirtualSymbolsTable[asset_index].tp)
                {
                 VirtualSymbolsTable[asset_index].position=0.00;                     
                 VirtualSymbolsTable[asset_index].tp=0.00;
                 VirtualSymbolsTable[asset_index].sl=0.00;
                }                    
             }                                       
          }
        new_equity=VirtualEquity[VirtualLastEquityPos].close+fluctuation;
        VirtualAddNewEquity(new_equity);             
       }
     return;
    }

VirtualMarkToMarket() is the heart of the entire class. It can be called for a position or for all positions. It marks positions to the market, calculating the account equity. For each position it calculates the fluctuation in equity from the last marked price to the current market price, which becomes marked price. For the same position, the procedure may clear the stop loss and take profits once these are taken. The user has to call VirtualMarkToMarket(-1) at every tick to mark positions to market.

void VirtualAccount::VirtualChangePosition(int asset_index,int direction,double price,double lotsize) //direction is ORDER_TYPE_BUY or ORDER_TYPE_SELL
    {
     int p=VirtualGetPositionType(asset_index);
     double rprice,fluctuation,new_equity;
     double oldposition;            
     if (p==FLAT)
       {
        VirtualSymbolsTable[asset_index].price=price;
        VirtualSymbolsTable[asset_index].marked_price=price;
        VirtualSymbolsTable[asset_index].sl=0.00000;
        VirtualSymbolsTable[asset_index].tp=0.00000;
        if (direction==ORDER_TYPE_BUY)             
          VirtualSymbolsTable[asset_index].position=NormalizeDouble(lotsize,2);
        if (direction==ORDER_TYPE_SELL)
          VirtualSymbolsTable[asset_index].position=NormalizeDouble(-lotsize,2);
        //Print("Position set to ",VirtualSymbolsTable[asset_index].position," @ price ",DoubleToString(VirtualSymbolsTable[asset_index].price,SymbolInfoInteger(VirtualSymbolsTable[asset_index].Symbol,SYMBOL_DIGITS) ) );
       }
     else
       {
        oldposition=VirtualSymbolsTable[asset_index].position;
        //local mark to market
        VirtualMarkToMarket(asset_index);           
        //position update
        VirtualSymbolsTable[asset_index].price=price;           
        if (direction==ORDER_TYPE_BUY)
          {
           VirtualSymbolsTable[asset_index].position=NormalizeDouble(VirtualSymbolsTable[asset_index].position+lotsize,2);
           if (oldposition<0.00&&VirtualSymbolsTable[asset_index].position>0.00||DoubleToString(VirtualSymbolsTable[asset_index].position,5)=="0.00000")
             {
              VirtualSymbolsTable[asset_index].sl=0.00000;
              VirtualSymbolsTable[asset_index].tp=0.00000;
             }
          }
        if (direction==ORDER_TYPE_SELL)
          {
           VirtualSymbolsTable[asset_index].position=NormalizeDouble(VirtualSymbolsTable[asset_index].position-lotsize,2);
           if (oldposition>0.00&&VirtualSymbolsTable[asset_index].position<0.00||DoubleToString(VirtualSymbolsTable[asset_index].position,5)=="0.00000")
             {
              VirtualSymbolsTable[asset_index].sl=0.00000;
              VirtualSymbolsTable[asset_index].tp=0.00000;
             }
          }              
        //Print("Position set to ",VirtualSymbolsTable[asset_index].position," @ price ",DoubleToString(VirtualSymbolsTable[asset_index].price,SymbolInfoInteger(VirtualSymbolsTable[asset_index].Symbol,SYMBOL_DIGITS) ) );
       }
    return;
   }

To make a trade, you have to use VirtualChangePosition() which will open a position with the given direction , price and lot size on the specified asset index. This opening is similar to a deal. Thus, only ORDER_TYPE_BUY and ORDER_TYPE_SELL are supported for operation. No pending or StopLimit orders. The function only sets or modifies positions. It also clears the previous stop loss and take profit if a position reverses sign.

Now that the class is done, we can virtualize the portfolio moving average expert from the MQL5 : A portfolio moving average sample expert article in a new file, called VirtualPortfolioMA.mq5 .

//+------------------------------------------------------------------+
//|                                           VirtualPortfolioMA.mq5 |
//|                                       Copyright Bogdan Caramalac |
//|                                           http://mqlmagazine.com |
//+------------------------------------------------------------------+
#property copyright "Copyright Bogdan Caramalac"
#property link      "http://mqlmagazine.com"
#property version   "1.00"
 
#define FLAT        0
#define LONG        1
#define SHORT       2
 
input int Slippage=30;
input double MarginUsagePerPosition=0.5;
input bool VolatilityFilter=false;
input int VirtualStopLoss=300;
input int VirtualTakeProfit=1000;
input int SlowMALength=14;
input int FastMALength=9;
 
input int EquitySlowMAPeriod=14;
input int EquityFastMAPeriod=9;
input int RealStopLoss=300;
input int RealTakeProfit=1000;

The variables are quite the same, with the distinction that now stop loss , take profit and moving average periods are split in two : for the virtual account and for the account the system runs on.

#include 
#include 
 
int SymbolsCount;
 
struct IndicatorHandlersStruct
  {
   int SlowMovingAverageHandler;
   int FastMovingAverageHandler;
   int BBoverSTDHandler;
  };
 
struct SymbolData
  {
    string Symbol;
    IndicatorHandlersStruct IndicatorHandlers;
    datetime LastBarTime;
  };
 
SymbolData SymbolsTable[30];
 
VirtualAccount VirtualSystem;    
 
datetime VirtualLastBarTime;
string RealTrading="FORBIDDEN";

The structures are quite similar. The class is instanced in the VirtualSystem object. A VirtualLastBarTime is added to record the open time of the last equity bar from the virtual account. The RealTrading variable will record the trading state with respect to copying trades from the virtual account, that is, “STRAIGHT”, “REVERSED”, or “FORBIDDEN” (only “STRAIGHT” and “FORBIDDEN” are actually used).

The VirtualMakeIndicatorHanders() takes place of the former MakeIndicatorHandlers(). The code is the same, only the name is changed.

void VirtualPositionSetSLTP(int asset_index,int sl,int tp)
  {
   VirtualSystem.VirtualPositionSetSL(asset_index,sl);
   VirtualSystem.VirtualPositionSetSL(asset_index,tp);
  }  
 
void VirtualManagePosition(int asset_index,int operation)
  {
   MqlTradeRequest request;
   MqlTradeResult result;
   int p;
   p=VirtualSystem.VirtualGetPositionType(asset_index);
   double now_volume;
   double current_volume,v0;
   current_volume=VirtualSystem.VirtualGetPositionSize(asset_index);
   v0=current_volume;   
   request.action=TRADE_ACTION_DEAL;
   request.symbol=SymbolsTable[asset_index].Symbol; 
   request.deviation=Slippage;
   request.type_filling=ORDER_FILLING_AON;
   request.type_time=ORDER_TIME_GTC;
   if (p==FLAT)
     {
      request.volume=UnitsToLots( (MarginUsagePerPosition/100)*VirtualSystem.VirtualLastAccountEquity*AccountInfoInteger(ACCOUNT_LEVERAGE),SymbolsTable[asset_index].Symbol );
      if (operation==LONG)
        {
         request.type=ORDER_TYPE_BUY;
         request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_ASK),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));
        }
      if (operation==SHORT)
        {
         request.type=ORDER_TYPE_SELL;
         request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_BID),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));
        }
     }
   else//if (p==FLAT)
     {      
      if (p==LONG&&operation==SHORT)
        {
         request.volume=current_volume+UnitsToLots( (MarginUsagePerPosition/100)*VirtualSystem.VirtualLastAccountEquity*AccountInfoInteger(ACCOUNT_LEVERAGE),SymbolsTable[asset_index].Symbol );
         request.type=ORDER_TYPE_SELL;         
         request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_BID),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));         
        }
      if (p==SHORT&&operation==LONG)
        {
         request.volume=current_volume+UnitsToLots( (MarginUsagePerPosition/100)*VirtualSystem.VirtualLastAccountEquity*AccountInfoInteger(ACCOUNT_LEVERAGE),SymbolsTable[asset_index].Symbol );
         request.type=ORDER_TYPE_BUY;
         request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_ASK),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));
        }
      if (p==LONG&&operation==FLAT)
        {
         request.volume=current_volume;
         request.type=ORDER_TYPE_SELL;         
         request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_BID),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));         
        }
      if (p==SHORT&&operation==FLAT)
        {
         request.volume=current_volume;
         request.type=ORDER_TYPE_BUY;         
         request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_ASK),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));         
        } 
      if (p==LONG&&operation==LONG)//adjustment of the present LONG position
        {
         request.volume=UnitsToLots( (MarginUsagePerPosition/100)*VirtualSystem.VirtualLastAccountEquity*AccountInfoInteger(ACCOUNT_LEVERAGE),SymbolsTable[asset_index].Symbol )-current_volume;
         if (NormalizeDouble(request.volume,2)>0.00)
           {         
            request.type=ORDER_TYPE_BUY;
            request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_ASK),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));
           }
         else //we close the difference
           {
            request.volume=MathAbs(request.volume);
            request.type=ORDER_TYPE_SELL;         
            request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_BID),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));         
           }
        }        
      if (p==SHORT&&operation==SHORT)//adjustment of the present SHORT position
        {
         request.volume=UnitsToLots( (MarginUsagePerPosition/100)*VirtualSystem.VirtualLastAccountEquity*AccountInfoInteger(ACCOUNT_LEVERAGE),SymbolsTable[asset_index].Symbol )-current_volume;
         if (NormalizeDouble(request.volume,2)>0.00)
           {
            request.type=ORDER_TYPE_SELL;         
            request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_BID),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));                  
           }
         else
           {
            request.volume=MathAbs(request.volume);
            request.type=ORDER_TYPE_BUY;
            request.price=NormalizeDouble(SymbolInfoDouble(SymbolsTable[asset_index].Symbol,SYMBOL_ASK),SymbolInfoInteger(SymbolsTable[asset_index].Symbol,SYMBOL_DIGITS));            
           }
        }        
     }//if (p==FLAT)
   if (request.volume>0.00)
     {       
      VirtualSystem.VirtualChangePosition(asset_index,request.type,request.price,request.volume);
      VirtualPositionSetSLTP(asset_index,VirtualStopLoss,VirtualTakeProfit);      
     }
   //deciding to replicate , stay out or reverse signals on real portfolio
   if (RealTrading!="FORBIDDEN")
     {
      if (RealTrading=="STRAIGHT")
        ManagePosition(asset_index,operation);
      else
        {
         if (operation==LONG)
           ManagePosition(asset_index,SHORT);
         if (operation==SHORT)
           ManagePosition(asset_index,LONG);
         if (operation==FLAT)
           ManagePosition(asset_index,FLAT);
        }
     }
   return;     
  }

This is the VirtualManagePosition(). It operates like ManagePosition() however its requests are directed towards the virtual account. At the end, after analysing the RealTrading variable, it decides whether to do nothing, to copy or to reverse virtual operations on the actual trading account.

The MASignal(), PositionSetSLTP(), and ManagePosition() remain the same as in the original expert.

void VirtualTradeLogics(int asset_index)
  {
   string s;
   double stddev[1];
   double bbhi[1];
   double bblo[1];
   int copycount;
   s=MASignal(asset_index);    
   if (VolatilityFilter==true)
     {
      copycount=CopyBuffer(SymbolsTable[asset_index].IndicatorHandlers.BBoverSTDHandler,0,0,1,stddev);
      copycount=CopyBuffer(SymbolsTable[asset_index].IndicatorHandlers.BBoverSTDHandler,2,0,1,bbhi);
     }
   if (VirtualSystem.VirtualGetPositionType(asset_index)==FLAT)
     {      
      if (s=="L")
        {
         if (VolatilityFilter==true)
           {
            if (stddev[0]>bbhi[0])
              VirtualManagePosition(asset_index,LONG);
           }
         else
           VirtualManagePosition(asset_index,LONG);
        }
      if (s=="S")
        {
         if (VolatilityFilter==true)
           {
            if (stddev[0]>bbhi[0])
              VirtualManagePosition(asset_index,SHORT);
           }
         else
           VirtualManagePosition(asset_index,SHORT);
        }
     }//else if (GetPositionType(asset_index)==FLAT)
   else//position is not flat
     {
      if (VirtualSystem.VirtualGetPositionType(asset_index)==LONG)
        {        
         if (VolatilityFilter==true)
           {
            if (s=="S"||stddev[0]<bbhi[0])
              VirtualManagePosition(asset_index,FLAT);
           }           
         else
           {            
            if (s=="S")
              {               
               VirtualManagePosition(asset_index,FLAT);           
              }
           }//if (VolatilityFilter==true)
        }
      if (VirtualSystem.VirtualGetPositionType(asset_index)==SHORT)
        {         
         if (VolatilityFilter==true)
           {
            if (s=="L"||stddev[0]<bbhi[0])
              VirtualManagePosition(asset_index,FLAT);
           }
         else
           {            
            if (s=="L")
              {               
               VirtualManagePosition(asset_index,FLAT);           
              }
           }//if (VolatilityFilter==true)        
        }//if (VirtualSystem.VirtualGetPositionType(asset_index)==SHORT)
     }           
   return;
  }

This is the former TradeLogics() , but modified in order to operate on the virtual account.

int PeriodToMinutes(ENUM_TIMEFRAMES p)
  {
   switch(p)
     {
      case PERIOD_M1:return(1);
      case PERIOD_M2:return(2);
      case PERIOD_M3:return(3);
      case PERIOD_M4:return(4);
      case PERIOD_M5:return(5);
      case PERIOD_M6:return(6);
      case PERIOD_M10:return(10);
      case PERIOD_M12:return(12);
      case PERIOD_M15:return(15);
      case PERIOD_M20:return(20);
      case PERIOD_M30:return(30);
      case PERIOD_H1:return(60);
      case PERIOD_H2:return(60*2);
      case PERIOD_H3:return(60*3);
      case PERIOD_H4:return(60*4);
      case PERIOD_H6:return(60*6);
      case PERIOD_H8:return(60*8);
      case PERIOD_H12:return(60*12);
      case PERIOD_D1:return(60*24);
      case PERIOD_W1:return(60*24*7);
      case PERIOD_MN1:return(60*24*30);
      default: return(0);
     }
  };

This function is used in OnInit() to setup the virtual account’s bar timespan , and it converts periods into minutes.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   SymbolsTable[0].Symbol="EURUSD";
   SymbolsTable[1].Symbol="USDJPY";
   SymbolsTable[2].Symbol="GBPUSD";
   SymbolsTable[3].Symbol="USDCHF";
   SymbolsCount=1;
 
   VirtualSystem.VirtualAccountSet(AccountInfoDouble(ACCOUNT_EQUITY),PeriodToMinutes(Period())*60);  
   VirtualSystem.VirtualSymbolsCount=SymbolsCount;      
   for (int i=0;i<SymbolsCount;i++)
      VirtualSystem.VirtualSymbolsTable[i].Symbol=SymbolsTable[i].Symbol;
   VirtualMakeIndicatorHandlers();
   VirtualLastBarTime=VirtualSystem.VirtualEquity[VirtualSystem.VirtualLastEquityPos].opentime;
   RealTrading="FORBIDDEN";
   return(0);
  }

This is OnInit(). It prepares symbols like former OnInit() then copies symbols to the virtual account. Sets up virtual account and makes sure RealTrading is set to “FORBIDDEN”.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {   
   double loweq;         
   double fast_ma_now,slow_ma_now,fast_ma_old,slow_ma_old;
   double EquityCloseBuffer[31];
   datetime datetime_array[1];   
   //marking to market virtual positions
   VirtualSystem.VirtualMarkToMarket(-1);
   //looping symbols to apply logics
   for (int i=0;i<SymbolsCount;i++)
      {
       CopyTime(SymbolsTable[i].Symbol,Period(),0,1,datetime_array);
       if (datetime_array[0]!=SymbolsTable[i].LastBarTime)
         {                  
          VirtualTradeLogics(i);
          SymbolsTable[i].LastBarTime=datetime_array[0];
         }//if (datetime_array[0]!=LastBarOccurred[i])
      }//for (int i=0;i
 
   //now we check if we have enough equity bars ; if true, we analyse to see whether we activate or not live trading
   if (VirtualSystem.VirtualEquity[VirtualSystem.VirtualLastEquityPos].opentime!=VirtualLastBarTime)
     {
      if (VirtualSystem.VirtualLastEquityPos>ArrayRange(EquityCloseBuffer,0))  
        {
         for (int i=1;i<=ArrayRange(EquityCloseBuffer,0)-1;i++)
            {         
             EquityCloseBuffer[i]=StringToDouble( DoubleToString(VirtualSystem.VirtualEquity[VirtualSystem.VirtualLastEquityPos-ArrayRange(EquityCloseBuffer,0)+1+i].close,2) );             
             loweq=StringToDouble( DoubleToString(VirtualSystem.VirtualEquity[VirtualSystem.VirtualLastEquityPos-ArrayRange(EquityCloseBuffer,0)+1+i].low,2));                
            }                                    
        }
      fast_ma_now=SimpleMA(ArrayRange(EquityCloseBuffer,0)-1,EquityFastMAPeriod,EquityCloseBuffer);
      slow_ma_now=SimpleMA(ArrayRange(EquityCloseBuffer,0)-1,EquitySlowMAPeriod,EquityCloseBuffer);
      fast_ma_old=SimpleMA(ArrayRange(EquityCloseBuffer,0)-2,EquityFastMAPeriod,EquityCloseBuffer);
      slow_ma_old=SimpleMA(ArrayRange(EquityCloseBuffer,0)-2,EquitySlowMAPeriod,EquityCloseBuffer);
      //bullish ma cross on virtual system's equity line      
      if (fast_ma_now>slow_ma_now&&fast_ma_old<slow_ma_old)
        {          
         RealTrading="STRAIGHT";
         //replicating virtual portfolio into real
         //position sizes are calculated to be proportional with the real account equity
         for (int i=0;i<SymbolsCount;i++)
            ManagePosition(i,VirtualSystem.VirtualGetPositionType(i), 
                    UnitsToLots(
                     (VirtualSystem.VirtualGetPositionSize(i)*
                      AccountInfoDouble(ACCOUNT_EQUITY)/
                      VirtualSystem.VirtualLastAccountEquity)*
                      SymbolInfoDouble(SymbolsTable[i].Symbol,SYMBOL_TRADE_CONTRACT_SIZE)
                      ,SymbolsTable[i].Symbol) );
        }
      //bearish ma cross on virtual system's equity line        
      if (fast_ma_now<slow_ma_now&&fast_ma_old>slow_ma_old)
        {
         RealTrading="FORBIDDEN";
         //closing real positions
         for (int i=0;i<SymbolsCount;i++)
            ManagePosition(i,FLAT);         
        }             
      VirtualLastBarTime=VirtualSystem.VirtualEquity[VirtualSystem.VirtualLastEquityPos].opentime;
     }
   return;
  }

This is the OnTick(). Like former OnTick(), it has a symbol loop and applies the logics for each symbol, on the virtual account this time. It declares the EquityCloseBuffer[] where last values of virtual acount equity bars are copied, after each loop is finished. When this buffer contains enough values, a moving average cross on the virtual account equity line is calculated. When these moving average yield a bullish signal, RealTrading is set to “STRAIGHT”. Portfolio is being replicated from the virtual account on the actual account, proportional to the size of actual account. Of course, the VirtualManagePosition() will have subsequent calls to ManagePosition() and from this time on both accounts will work in the same time. When the moving average cross becomes bearish, RealTrading is set to “FORBIDDEN” and actual account positions are closed.

The OnDeinit() is exactly the same, as the indicator handlers are residing in the same SymbolsTable[].

Surprised? The portfolio run is more unstable than one pair run, as it was for the main trading system. The extra volatility translated into range movements on the equity line, which in turn translated into false positive signals given by moving averages on the equity line, making the virtualization to be a fiasco. There are at least three points to consider:

1. Sampling frequency
What is the optimal sampling frequency for the equity moving average? After all, we don’t know exactly how MetaTrader compresses equity data on bars so we don’t know its own sampling interval. Then, how to sample for the average ?

2. Optimal trading system for the equity line
Nobody said that moving averages over equity are the best way to fit. Other criterias may apply, same as in regular trading.

3. Should you trade all the instruments in the same virtual account, or trade in separate virtual accounts and fit each one’s equity ?

The main conclusion that yields is that trading systems are not to be based on cold, pure application of indicators. Indicators, as their name says, are indicating some of the actions that have to be taken, as counselors that give advices, influencing positively the results of trading systems, but their place is not at the core of trading systems. Rather, sound statistics and arbitrage relationships are at the base of effective trading systems.

File links:
TradeVirtualization.mqh
VirtualPortfolioMA.mq5

MQL5 : Implementation of a simple CEP engine

Bogdan Caramalac, MQLmagazine sr.editor — Mon, 24 May 2010 21:28:51 +0000

[Versiunea romaneasca] [MQLmagazine.com in romana] [English edition]

This edition was harder to make than any of the previous editions. The late release of Strategy Tester and the large number of bugs that surged while making the CEP engine took a lot of time. From this moment, magazine issues will not be monthly anymore, because they will contain a lot of work and updates of past works. This is why, this time we are adding the Forum to the Magazine.

Now back to the CEP engine.

The CEP engine was some of the hardest stuff possible to write in MQL5. It was hard not only for me as programmer, but it had implications over MT5 as well, because the spaghetti data structure that it uses put MetaTrader to the test ; it needed a lot of bug filtering, especially on objects and memory allocations. The code managed to run with minor issues barely on build 270 (yes, already in May), and completely clean on build 271. It’s a long hard code, and I’ll chop it to pieces for commenting. I also left inline comments and Print lines intact to be better understood by readers. The algorithm is quite modified, not the same as the one presented in Anatomy of a Simple CEP Engine .

The following file it’s gonna be called CEPEngine.mqh :

//+------------------------------------------------------------------+
//|                                                    CEPEngine.mqh |
//|                                       Copyright Bogdan Caramalac |
//|                                           http://mqlmagazine.com |
//+------------------------------------------------------------------+
#property copyright "Bogdan Caramalac"
#property link      "http://mqlmagazine.com"
 
#property version "1.0";
 
//*******************************************
 
string Replicate(string s,int n)
   {
   string res="";
   int k=1;
   if (n<1)
      return(res);                    
   for (k=1;k<=n;k++) 
       {
        StringConcatenate(res,res,s);
       }
    return(res);
   }          
 
string BoolToString(bool b)
  {
   if (b==true)
     return(".T.");
   else
     return(".F.");   
  }
 
//*******************************************

These are very simple string functions, that are needed for the larger functions that translate structures into string messages, descriptions of several CEP structures. The first function will replicate a string, and the second one will return a string for a boolean , in a FoxPro-ish style.

struct SimpleEvent
  {
   public:
   uint EventID;
   uint EventTime;
   uint Reserved;
   ushort BindCount;
   uint Binds[100];
  };
 
   bool BindEvent(uint eventid,SimpleEvent& s)
     {
      bool fd;
      if (s.BindCount==0)
        {
         s.Binds[0]=eventid;
         s.BindCount++;
         return(true);
        }
      else
        {
         fd=false;
         //checking previous bind
         for (int i=0;i<s.BindCount;i++)
            {
             if (s.Binds[i]==eventid)
               {
                fd=true;
                break;
               }
            }//for (int i=0;i
         if (fd==false)
           {
            if (s.BindCount<ArrayRange(s.Binds,0)-1)
              {
               s.Binds[s.BindCount]=eventid;
               s.BindCount++;
               return(true);
              }
            else
              return(false);
           }
         else
           return(false);
        }//else if (s.BindCount!=0)
     }
 
   int FindBind(uint eventid,SimpleEvent& s)
     {
      bool fd;
      if (s.BindCount==0)
        {
         return(-1);
        }
      else
        {
         fd=false;
         //checking previous bind
         for (int i=0;i<s.BindCount;i++)
            {
             if (s.Binds[i]==eventid)
               {
                return(i);
                break;
               }
            }//for (int i=0;i
         return(-1);
        }
     }     
 
   bool UnbindEvent(uint eventid,SimpleEvent& s)
     {
      if (s.BindCount==0)
        return(false);
      int fd;
      fd=-1;
      for (int i=0;i<s.BindCount;i++)
         {
          if (s.Binds[i]==eventid)
            {
             fd=i;
             break;
            }
         }//for (int i=0;i
      if (fd==0)
        return(false);
      else
        {
         for (int j=fd+1;j<s.BindCount;j++)
            {
             s.Binds[j-1]=s.Binds[j];
            }
         s.Binds[s.BindCount-1]=0;
         s.BindCount--;
         return(true);
        }//if (fd==0)
     }

The SimpleEvent structure is at the core of the engine. The events queue that I described in my previous article it is made by tiny SimpleEvent structures. EventID plays the ID, EventTime is the time (in ticks – milliseconds since Windows start – not datetime format), BindCount tells to how many complex events the simple event is binded, and the Binds[] contains these events. The BindEvent(), FindBind() and UnbindEvent() functions are to work with this structure. Normally, I could have opted for a class instead of a structure, but what you gain in class functionality you lose in data maneuvrability : you cannot copy objects, but field by field, otherwise you get Structure have objects and cannot be copied.

struct SimpleEventArrangement
  {
   int EventCount;
   uint EventArray[100];
   int Prebinds[100];
   int NegationsCount[100]; //how many negation events before each event from the array
   uint NegationsArray[10][100]; //store negation events before each event from the array
   bool NegationsChecked[100];//checks of the first negations that match
  };
 
struct ComplexEvent
  {
   uint ComplexID;
   uint TimeConstraint;
   ushort ArrangementsCount;
   SimpleEventArrangement ArrangementsArray[100];
  };

The ComplexEvent structure is the base unit of the complex events table. Remember the pic from the previous article? That is quite what can be found in the ComplexEvent structure. Thus, we have the ID , time constraint, arrangements count (number of rows) , or versions of event queues that make up the same complex event, and finally an arrangements array, made up by SimpleEventArrangement(s).

The SimpleEventArrangement structure describes what can be called to be a row of that matrix. Thus we have a count, and the row (meaningly, the EventArray[]) , which contains the required simple events. The Prebinds[] will note down of course, the prebinds of these events, meaningly the position in the event queue for each simple event that is found. The NegationsCount[] will contain how many negation events are required not to appear before every simple event that is required. Thus, one count per each required simple event. The NegationsArray[] will contain these events required not to appear, on columns, rather than on lines. The NegationsChecked[] array is a sort of shortened prebind array. Instead of storing where the negations appear, a simple negation flag is raised in this array, thus the array is unidimensional.

void MakeSimpleEventArrangement(string s,SimpleEventArrangement& arrg)
  {
   int len=StringLen(s+" ");
   string rdnow="";
   string c;
   uint number,swap;
   int normcount;
   arrg.EventCount=0;
   string first;
   int intg,d,crt;
   double dbl;
   s=s+" ";//to make sure it registers last word
   ArrayInitialize(arrg.EventArray,0);
   ArrayInitialize(arrg.NegationsCount,0);
   ArrayInitialize(arrg.NegationsArray,0);
   ArrayInitialize(arrg.Prebinds,-1);
   ArrayInitialize(arrg.NegationsChecked,false);
   normcount=-1;
   if (len!=0)
     {
      for (int i=0;i<len;i++)
         {
          c=StringSubstr(s,i,1);
          if (c==" ")
            {
             if (rdnow!="")
               {
                first=StringSubstr(rdnow,0,1);
                if (first=="-"||first=="!"||first=="n"||first=="N")
                  {
                   number=StringToInteger(StringSubstr(rdnow,1,StringLen(rdnow)-1));
                   if (normcount!=-1)   
                     {
                      arrg.NegationsArray[normcount][arrg.NegationsCount[normcount]]=number;
                      arrg.NegationsCount[normcount]++;
                     }                  
                  }
                else
                  {
                   normcount++;
                   number=StringToInteger(StringSubstr(rdnow,0,StringLen(rdnow) ));
                   arrg.EventArray[normcount]=number;
                   arrg.EventCount=normcount+1;
                  }
                rdnow="";
               }//if (rdnow!="")                
            }//if (c==" ")
          else
            {
             StringConcatenate(rdnow,rdnow,c);
            }
         }//for (int i=0;i
       if (rdnow!="")
         {
          first=StringSubstr(rdnow,0,1);
          if (first=="-"||first=="!"||first=="n"||first=="N")
            {
             number=StringToInteger(StringSubstr(rdnow,1,StringLen(rdnow)-1));
             if (normcount!=-1)   
               {
                arrg.NegationsArray[normcount][arrg.NegationsCount[normcount]]=number;
                arrg.NegationsCount[normcount]++;
               }                  
            }
          else
            {
             normcount++;
             number=StringToInteger(StringSubstr(rdnow,0,StringLen(rdnow) ));
             arrg.EventArray[normcount]=number;
             arrg.EventCount=normcount+1;
            }
          rdnow="";
         }//if (rdnow!="")
 
      //reversing event order
      if (arrg.EventCount>0)
        {
         dbl=NormalizeDouble(arrg.EventCount/2,0);
         intg=NormalizeDouble(MathRound(NormalizeDouble(arrg.EventCount,0)/2),0);
         if (dbl==intg)
           d=0;
         else
           d=1;           
         crt=0;         
         for (int i=0;i<=intg-1-d;i++)
            {             
             swap=arrg.EventArray[i];
             arrg.EventArray[i]=arrg.EventArray[arrg.EventCount-1-crt];
             arrg.EventArray[arrg.EventCount-1-crt]=swap;             
             for (int l=0;l<ArrayRange(arrg.NegationsArray,0);l++)
                {                 
                 swap=arrg.NegationsArray[l][i];
                 arrg.NegationsArray[l][i]=arrg.NegationsArray[l][arrg.EventCount-1-crt];
                 arrg.NegationsArray[l][arrg.EventCount-1-crt]=swap;
                }
             crt++;
            }
        }
 
     }//if (len!=0)
   return;
  }

The MakeSimpleArrangement() function will build a simple arrangement, from a string, as instructed by the user. For instance, “10 !6 11″ means “10, followed by 11, with a 6 that has not to appear before 11″. Spacebar is separator, and negation flag can be “-”,”!”,”n” or “N”. Note that at the end of the function, data is reversed, from last to first, as I said in the previous article, that complex event arrangements will start from the nearby events going to the older events. This function has not to be called by the user, rather it is called by MakeComplexEvent().

void MakeComplexEvent(string s,uint eventid,uint time,ComplexEvent &cplx)
  {
   int len=StringLen(s+" ");
   string rdnow="";
   string c;
   string arrg;
   ushort cnt;
   s=s+" ";
   cplx.ComplexID=eventid;
   cplx.TimeConstraint=time;
   cplx.ArrangementsCount=0;
   if (len!=0)
     {
      for (int i=0;i<len;i++)
         {
          c=StringSubstr(s,i,1);
          if (c==";")
            {
             if (rdnow!="")
               {
                MakeSimpleEventArrangement(rdnow,cplx.ArrangementsArray[cplx.ArrangementsCount]);
                cplx.ArrangementsCount++;
                rdnow="";
               }//if (rdnow!="")
            }//if (c==" ")
          else
            StringConcatenate(rdnow,rdnow,c);
         }//for (int i=0;i
      //for last word
      if (rdnow!="")
        {
         MakeSimpleEventArrangement(rdnow,cplx.ArrangementsArray[cplx.ArrangementsCount]);
         cplx.ArrangementsCount++;
         rdnow="";
        }//if (rdnow!="")
     }//if (len!=0)
   return;
  }

The MakeComplexEvent() function is to be called by user when telling the engine how the complex events look like. The definition is a big string with more simple event arrangements, separated by semicolon. The other parameters are the complex event ID, the time constraint and a complex event variable to store the result in.

string ComplexEventToString(ComplexEvent& c)
  {
   string res="";
   res=res+"ComplexID "+DoubleToString(c.ComplexID,0)+"\n";
   res=res+"Arrangements "+DoubleToString(c.ArrangementsCount,0)+"\n";
   for (int i=0;i<c.ArrangementsCount;i++)
      {
       res=res+"Events: "+DoubleToString(c.ArrangementsArray[i].EventCount,0)+"\n";
       for (int j=0;j<c.ArrangementsArray[i].EventCount;j++)
          {
           res=res+" "+DoubleToString(c.ArrangementsArray[i].EventArray[j],0);
          }
       res=res+"\n";       
       res=res+"Negations:\n";
       for (int j=0;j<10;j++)
          {
           for (int k=0;k<c.ArrangementsArray[i].EventCount;k++)
              {
               res=res+" "+DoubleToString(c.ArrangementsArray[i].NegationsArray[j][k],0);
              }
           res=res+"\n";
          }
       res=res+"\n";
      }
   return(res);
  }

This function was made for commenting reasons only. The function describes a complex event in a string form. You can output the resulting string with Comment().

class CEPEngine
  {
   //setup elements
   private:
   uint QueueTimeConstraint;
   ComplexEvent ComplexEventsTable[30];
   ushort ComplexEventsCount;
   //data
   SimpleEvent EventsQueue[1000];    
   int OldestIndex;
   uint OldestTime;
 
   public:
   void CEPEngine();//constructor
   void ClearEvents();//cleans event table
   void AddComplexEvent(ComplexEvent &c);   
   virtual void EventsCallback(uint EventID);//here you treat raised events from the CEP Engine
   void SetupEngineMilliseconds(uint ms);
   void RaiseEvent(uint EventID);
   void EngineRun();
   string StatusString();
   };

Finally, we got to the CEP engine class.
QueueTimeConstraint is an important variable, which tells which is the length in time for which the engine will look in the queue. Incoming simple events, that are found in the EventsQueue[] , and go past this “event horizon” are overwritten. The OldestIndex is the end of the array ; it is a dynamic end, calculated at every new RaiseEvent() call from the outside, abiding the QueueTimeConstraint, and it has the time , in ticks, in OldestTime.

Now the small stuff:

   void CEPEngine::ClearEvents()  //cleans event table
     {
      for (int i=0;i<ArrayRange(ComplexEventsTable,0);i++)
         {
          ComplexEventsTable[i].ArrangementsCount=0;
         }
      for (int i=0;i<ArrayRange(EventsQueue,0);i++)
          {
           EventsQueue[i].EventID=0;
           EventsQueue[i].EventTime=0;
           EventsQueue[i].BindCount=0;
           ArrayInitialize(EventsQueue[i].Binds,0);
          }
      OldestIndex=-1;
      OldestTime=0;
      ComplexEventsCount=0;
     }  
 
   void CEPEngine::CEPEngine()
     {
      ClearEvents();
     }
 
   void CEPEngine::AddComplexEvent(ComplexEvent &c)
     {
      ComplexEventsTable[ComplexEventsCount]=c;
      ComplexEventsCount=ComplexEventsCount+1;
     }
 
 
   void CEPEngine::SetupEngineMilliseconds(uint ms)
     {
      QueueTimeConstraint=ms;
      return;
     }
 
 
   void CEPEngine::EventsCallback(uint EventID)//here you treat raised events from the CEP Engine
     {
     }   
 
    string CEPEngine::StatusString()
       {
        string res="";
        string eventtext;
        int etl;
        if (ComplexEventsCount!=0)
          {
           for (int c=0;c<ComplexEventsCount;c++)
              {
               eventtext="["+DoubleToString(ComplexEventsTable[c].ComplexID,0)+"]::";
               etl=StringLen(eventtext);
               res=res+eventtext;
               if (ComplexEventsTable[c].ArrangementsCount!=0)
                 {
                  for (int a=0;a<ComplexEventsTable[c].ArrangementsCount;a++)
                     {                     
                      if (ComplexEventsTable[c].ArrangementsArray[a].EventCount!=0)
                        {                         
                         for (int e=0;e<ComplexEventsTable[c].ArrangementsArray[a].EventCount;e++)
                            {
                             res=res+DoubleToString(ComplexEventsTable[c].ArrangementsArray[a].Prebinds[e],0)+"  ";
                            }
                         res=res+"\n"+Replicate(" ",etl);
                         for (int e=0;e<ComplexEventsTable[c].ArrangementsArray[a].EventCount;e++)
                            {
                             res=res+BoolToString(ComplexEventsTable[c].ArrangementsArray[a].NegationsChecked[e])+"  ";
                            }
                         res=res+"\n";
                         if (a!=ComplexEventsTable[c].ArrangementsCount-1)
                           {
                            res=res+Replicate(" ",etl);
                           }                      
                        }//if (ComplexEventsTable[c].ArrangementsArray[a].EventCount!=0)                   
                     }//for (int a=0;a
                 }//if (ComplexEventsTable[c].ArrangementsCount!=0)
              }//for (int c=0;c
          }//if (ComplexEventsCount!=0) 
        return(res);
       }

So, the ClearEvents() clears the simple events queue. This is the reason for which it is called from the CEPEngine() constructor. The AddComplexEvent() adds a complex event to the table. It has to be called by user, after making complex events with MakeComplexEvent(). The engine is ready to work after its time constraint is set up by the user with SetupEngineMilliseconds(). And finally, the EventsCallback() is the virtual method that has to be overridden by the user, being called when the CEP engine raises a complex event.
The StatusString() function produces a comment version of the engine status.

Now some average complicated stuff: RaiseEvent() : when the user raises a simple event

    void CEPEngine::RaiseEvent(uint EventID)
      {
       long time=GetTickCount();
       bool isforbidden=true;
       uint opposite=0;
       uint difft;
       if (OldestIndex>0)
         {
          for (int i=0;i<ArrayRange(EventsQueue,0);i++)
             {
              if (EventsQueue[i].EventTime==0)
                {
                 OldestIndex=i-1;
                 OldestTime=EventsQueue[i-1].EventTime;
                 break;
                }
              if (time-EventsQueue[i].EventTime>QueueTimeConstraint)
                {
                 OldestIndex=i-1;
                 OldestTime=EventsQueue[i-1].EventTime;
                 break;
                }//if (time-EventsQueue[i].EventTime>QueueTimeConstraint)  
             }//for (int i=0;i
         }//if (OldestIndex!=0)
       else
         {
          if (OldestIndex<=0)
            {
             OldestIndex=0;
             OldestTime=time;
            }
         }
       for (int j=OldestIndex+1;j>0;j--)
          {
           EventsQueue[j].EventID=EventsQueue[j-1].EventID;
           EventsQueue[j].EventTime=EventsQueue[j-1].EventTime;
           EventsQueue[j].BindCount=EventsQueue[j-1].BindCount;
          }
       ArrayInitialize(EventsQueue[0].Binds,0);
       EventsQueue[0].EventID=EventID;
       EventsQueue[0].EventTime=time;
       EventsQueue[0].BindCount=0;
       OldestIndex=OldestIndex+1;
 
       if (ComplexEventsCount!=0)
         {
          EngineRun();
         }         
       return;
      }//raise event ends

The function has a moderate degree of complexity.
Lines 7 – 32 establish the event horizon within the queue. That is, which is the oldest event within the queue, abiding the time constraint of the whole queue.
Lines 33 – 38 move the queue one step lower , making room for a new simple event.
Lines 39 – 43 insert the new simple event coming from the user program.
Lines 45 – 48 call the EngineRun() method is to process the new data, if at least one complex event is registered in the table.

At the heart of the CEP engine lies the EngineRun() method. It is the most complicated piece of code of the entire class. But, there would be no car without the engine, right?

   void CEPEngine::EngineRun()
     {
      long time=GetTickCount();
      bool any_binded;
      int CrtColumn[100][100];//address CrtColumn as CrtColumn(event,arrangement)
      bool bypass=false;
      int q,p;
      int j,lastj;
      int test;
      if (ComplexEventsCount==0)
        return;
      ArrayInitialize(CrtColumn,0);
      for (int c=0;c<ComplexEventsCount;c++)
         {
          Print("Arrangements in complex event ",c," are ",ComplexEventsTable[c].ArrangementsCount);
          if (ComplexEventsTable[c].ArrangementsCount!=0)
            {                          
             for (int a=0;a<ComplexEventsTable[c].ArrangementsCount;a++)
                {      
                 //Check if the current simple event within arrangement within current complex event is to be binded
                 //by checking with simple events from the queue
                 p=0;                                       
                 while (time-EventsQueue[p].EventTime<=ComplexEventsTable[c].TimeConstraint)
                   {
                    Print("Looking on entry ",p," where is simple event ",EventsQueue[p].EventID," comparing with ",ComplexEventsTable[c].ArrangementsArray[a].EventArray[CrtColumn[c][a]]," on complex event ",c,", arrg. ",a," (column ",CrtColumn[c][a],") vs count ",ComplexEventsTable[c].ArrangementsArray[a].EventCount);                       
                    if (EventsQueue[p].EventID==ComplexEventsTable[c].ArrangementsArray[a].EventArray[CrtColumn[c][a]])
                      {
                       Print("Found simple event ",EventsQueue[p].EventID," for column ",CrtColumn[c][a]," of arrangement ",a," of event ",c," meaningly id=",ComplexEventsTable[c].ComplexID); 
                       ComplexEventsTable[c].ArrangementsArray[a].Prebinds[CrtColumn[c][a]]=p;
                       CrtColumn[c][a]++;                                                                                        
                       bypass=false;
                       if (CrtColumn[c][a]>1)
                         {
                          q=ComplexEventsTable[c].ArrangementsArray[a].Prebinds[CrtColumn[c][a]-2];
                          //-2 instead of -1 because we already incremented the CrtColumn by ++
                          Print("Checking negations from previous bind, ",q," to current element ",p);
                          q=q+1;
                          //Checking negations; if test passes, simple event is prebinded;                                                          
                          //q is an older event than the current one, p, so q>p
                          if (ComplexEventsTable[c].ArrangementsArray[a].NegationsCount[a]!=0)
                            {                                                
                             while (q<p)
                               {
                                for (int j=0;j<ComplexEventsTable[c].ArrangementsArray[a].NegationsCount[a];j++)
                                   {
                                    lastj=j;
                                    Print("Comparing event on ",q," meaningly ",EventsQueue[q].EventID," with negation ",ComplexEventsTable[c].ArrangementsArray[a].NegationsArray[j][CrtColumn[c][a]-2+1]);
                                    if (EventsQueue[q].EventID==ComplexEventsTable[c].ArrangementsArray[a].NegationsArray[j][CrtColumn[c][a]-2+1])
                                      {
                                       ComplexEventsTable[c].ArrangementsArray[a].NegationsChecked[j]=true;
                                       break;
                                      }
                                   }
                                 if (ComplexEventsTable[c].ArrangementsArray[a].NegationsChecked[lastj]==true)
                                   break;
                                 q++;
                                }
                            }//if (ComplexEventsTable[c].ArrangementsArray[a].NegationsCount!=0)
                          if (ComplexEventsTable[c].ArrangementsArray[a].NegationsChecked[lastj]==true)
                            {
                             Print("Erasing last bind on ",CrtColumn[c][a]-1,". Decreasing current column for complex ",c,", arrangement ",a);
                             ComplexEventsTable[c].ArrangementsArray[a].Prebinds[CrtColumn[c][a]-1]=-1;//erase prebind;                                  
                             CrtColumn[c][a]--;
                             bypass=true;
                             break;
                            } 
                         }//if (CrtColumn[c,a]>1)                            
                       if (bypass==false)//meaning,if no negations are checked                          
                         {
                          if (ComplexEventsTable[c].ArrangementsArray[a].EventCount==CrtColumn[c][a])//all prebinds are done
                            {
                             //checking time constraint again
                             if (GetTickCount()-EventsQueue[ComplexEventsTable[c].ArrangementsArray[a].Prebinds[ComplexEventsTable[c].ArrangementsArray[a].EventCount-1]].EventTime<=ComplexEventsTable[c].TimeConstraint)
                               {
                                //before binding, will check if any of these events is previously binded to the same event
                                any_binded=false;
                                for (int e=0;e<ComplexEventsTable[c].ArrangementsArray[a].EventCount;e++)
                                   {
                                    Print("Prebind",ComplexEventsTable[c].ArrangementsArray[a].Prebinds[e]," bind location of complex event id ",ComplexEventsTable[c].ComplexID," : ",FindBind(ComplexEventsTable[c].ComplexID,EventsQueue[ComplexEventsTable[c].ArrangementsArray[a].Prebinds[e]]));
                                    if (FindBind(ComplexEventsTable[c].ComplexID,EventsQueue[ComplexEventsTable[c].ArrangementsArray[a].Prebinds[e]])!=-1)
                                      {
                                       any_binded=true;
                                       Print("One event is already binded to complex event ",ComplexEventsTable[c].ComplexID);
                                       break;
                                      }
                                   }
                                if (any_binded==false)
                                  {
                                   //binding event
                                   for (int e=0;e<ComplexEventsTable[c].ArrangementsArray[a].EventCount;e++)
                                      {
                                       Print("Binding simple event on ",ComplexEventsTable[c].ArrangementsArray[a].Prebinds[e]," to ",ComplexEventsTable[c].ComplexID);
                                       BindEvent(ComplexEventsTable[c].ComplexID,EventsQueue[ComplexEventsTable[c].ArrangementsArray[a].Prebinds[e]]);
                                      }                       
                                   EventsCallback(ComplexEventsTable[c].ComplexID);//raise complex event for user to handle                                   
                                  }//if (any_binded==false)                                
                                break;//search exhausted for current arrangement of current complex event
                                      //it's either complete, so pointless to look forward
                                      //or one of the simple events is binded to the same complex event, again pointless
                               }//if (GetTickCount()-EventsQueue[ComplexEventsTable[c].ArrangementArray[a].Prebinds[...]].EventTime<=ComplexEventsTable[c].TimeConstraint)
                             else//it's a flop: completed too late; deleting binds
                               {                                      
                                for (int f=0;f<ComplexEventsTable[c].ArrangementsArray[a].EventCount;f++)
                                   {
                                    Print("Unbinding simple event from ",ComplexEventsTable[c].ArrangementsArray[a].Prebinds[f]," to ",ComplexEventsTable[c].ComplexID);
                                    UnbindEvent(ComplexEventsTable[c].ComplexID,EventsQueue[ComplexEventsTable[c].ArrangementsArray[a].Prebinds[f]]);
                                    ComplexEventsTable[c].ArrangementsArray[a].Prebinds[f]=-1;
                                    ComplexEventsTable[c].ArrangementsArray[a].NegationsChecked[f]=false;
                                   }//for (int f=0;f
                                 break;//no point to look forward , time`s up already
                               }//else if (GetTickCount()-EventsQueue[ComplexEventsTable[c].ArrangementArray[a].Prebinds[...]].EventTime<=ComplexEventsTable[c].TimeConstraint)
                            }//if (ComplexEventsTable[c].ArrangementsArray[a].EventCount==CrtColumn[c][a])
                         }//else if (bypass==true)                                                                                                 
                      }//if (EventsQueue[p].EventID==ComplexEventsTable[c].ArrangementsArray[a].EventArray[CrtColumn[c,a]])
                    p++;
                   }//while (time-EventsQueue[p].EventTime<=ComplexEventsTable[c].TimeConstraint)
                }//for (int a=0;a
            }//if (ComplexEventsTable[c].ArrangementsCount!=0)
         }//for (int c=0;c
 
      for (int c=0;c<ComplexEventsCount;c++)
         {          
          if (ComplexEventsTable[c].ArrangementsCount!=0)
            {
             for (int a=0;a<ComplexEventsTable[c].ArrangementsCount;a++)
                {                     
                 if (ComplexEventsTable[c].ArrangementsArray[a].EventCount!=0)
                   { 
                    if (CrtColumn[c][a]<ComplexEventsTable[c].ArrangementsArray[a].EventCount)
                      {
                       //removing prebinds
                       for (int f=0;f<ComplexEventsTable[c].ArrangementsArray[a].EventCount;f++)
                          {
                           ComplexEventsTable[c].ArrangementsArray[a].Prebinds[f]=-1;
                           ComplexEventsTable[c].ArrangementsArray[a].NegationsChecked[f]=false;
                          }//for (int f=0;f
                      }//if (CrtColumn[c][a]
                   }//if (ComplexEventsTable[c].ArrangementsArray[a].EventCount!=0)                       
                }//for (int a=0;a
            }//if (ComplexEventsTable[c].ArrangementsCount!=0)
         }//for (int c=0;c
      return;
     }

The function contains two loops. One is the main loop, lines 13 – 117 , and the second loop is 120 – 140. The second loop has a cleanup role to be explained below.

The main loop will go thru the ComplexEventsTable, to check which appear. For each complex event within this table, the arrangements will be checked, and for each arrangement, a series of procedures will be performed.
Inside this loop, another while loop will pass thru the EventsQueue[], (lines 23 – 115) from the first to the last, looking for events that match the time constraint of the current complex event. One of the most important variables inside this method is the CrtColumn[] array. This one stores the current pointer (current column in the unidimensional EventArray[]). Thus, the procedure checks the current required simple event from the table with the one found in the queue (line 26) , prebinds it and increases the CrtColumn[] value for the current complex event arrangement (lines 29 – 31). Since CrtColumn[] is initialized with zeros, if it finds first event, it is increased to 1. Now, if the CrtColumn[] is higher than one (meaning that the second event was found, and preparing to find the third) it is necessary to check if between the previous two events (e.g. first and the second, in this case) there are negation events (the ones that are forbidden from appearing), only if the NegationsCount[] for that specific simple event is nonzero (lines 40 – 59). If one negation event appears, it will break the search – pointless for the current arrangement. It also sets the bypass variable to true, for the following code, however that is just a programming technique to make the listing look better – the following code will be executed only if no negations appear in the meanwhile. Since events array is zero based, the maximum event that can be binded is EventCount-1, and, if CrtColumn[] for the current arrangement is equal to EventCount, then all events were prebinded. The complex event is like already done. What follows happens only if the oldest event still matches the time constraint. It will check if at least one of the pre-binded events of this pass was binded for real to the analysed complex event, already. In this case, will raise the any_binded flag to be true, and break. If the flag is not raised, then the complex event is considered completed in this arrangement, simple events are binded to the complex event , EventsCallback() is called to notify the user and current search is breaked (lines 90-96) . Otherwise, pre-binding is failed – happens too late. Events are unbinded, negations and prebinds are erased, search it’s breaked – no point to look forward if it’s too late already.

Then what comes is a secondary loop, lines 121 – 141. Since events are mapped from the nearest to the oldest, they are reported to the user creating incomplete complex events whose “shadowing” that manifests into future prohibiting same complex event from being reported, should it appear again, but made by other simple events. All the prebinds are removed, only definitive binds remain valid. Note, however, that the same complex event, conceptually, may be triggered more times than once, by different arrangements, if these contain completely different simple event streaks (e.g. 15 and 16 or 11 and 10 , if all four appear , meaning the same event, both arrangements will be reported as complex events with the same ID, but distinct) because the engine will not be able know if the event appeared again or these mean the same one.

You may question about negations, as you see negations are event specific, each event having its own negation events before it and the previous event. The current engine does not support global negations. However, if you want some events to be global negations, they have to be set up between every two consecutive simple events. The first event in the queue may have negations assigned, however these will not be checked, because there would be no known timeframe where to check for them. Negations are valid only between consecutive simple events.

This is a script example using the CEP engine in a test. The test consist in passing abstract events to the CEP engine. Let’s call it ceptest.mq5 .

//+------------------------------------------------------------------+
//|                                                      ceptest.mq5 |
//|                                        Copyright Bogdan Caramalac|
//|                                           http://mqlmagazine.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
 
#include 
 
 
//our class: we needed it to override EventsCallback;
class LocalCEPEngine : public CEPEngine
  { 
    void EventsCallback(uint EventID)
     {
      Print("COMPLEX EVENT RECOGNIZED: ",EventID);
     }   
  };
 
//the CEP engine object
LocalCEPEngine myengine;
 
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   uint tickstart,tick;
   ulong AbstractEvent;
   ComplexEvent c;
   //setting up engine time span
   myengine.SetupEngineMilliseconds(10000);
   //creating complex events
   MakeComplexEvent("10 !6 11 ; 10 12 13 ; 10 13 12",1111,2000,c); //the event for MSFT;  
   myengine.AddComplexEvent(c);   
   //note the events with ! are negations
   MakeComplexEvent("5 !7 15 ; 5 !7 16 17 ; 5 !7 17 !7 !9 16",2222,3000,c); //the event for ^GSPC;
   myengine.AddComplexEvent(c); 
 
   tickstart=GetTickCount();
   tick=tickstart;
 
//alternate tests:
   myengine.RaiseEvent(10);   
   Print("*****************************************************************************************************************");
   myengine.RaiseEvent(6);   
   Print("*****************************************************************************************************************");   
   myengine.RaiseEvent(11);   
   Print("*****************************************************************************************************************");
   myengine.RaiseEvent(10);
   Print("*****************************************************************************************************************");
   myengine.RaiseEvent(11);   
   Print("*****************************************************************************************************************");
   return;
}

This one generates for instance the following output:

I invite you to check the logs, look how the system is working. Try other tests:
Like this:

//alternate tests:
   myengine.RaiseEvent(10);   
   Print("*****************************************************************************************************************");
   myengine.RaiseEvent(11);
   Print("*****************************************************************************************************************");
   return;

Or like this:

//alternate tests:
   myengine.RaiseEvent(10);   
   Print("*****************************************************************************************************************");
   myengine.RaiseEvent(6);   
   Print("*****************************************************************************************************************");   
   myengine.RaiseEvent(11);   
   Print("*****************************************************************************************************************");

Or like this:

//alternate tests:
   myengine.RaiseEvent(10);   
   Print("*****************************************************************************************************************");
   myengine.RaiseEvent(11);   
   Print("*****************************************************************************************************************");
   myengine.RaiseEvent(10);
   Print("*****************************************************************************************************************");
   return;

Or like this:

//alternate tests:
   myengine.RaiseEvent(10);   
   Print("*****************************************************************************************************************");
   myengine.RaiseEvent(11);   
   Print("*****************************************************************************************************************");
   myengine.RaiseEvent(10);
   Print("*****************************************************************************************************************");
   myengine.RaiseEvent(11);   
   Print("*****************************************************************************************************************");
   return;

Now you gonna ask me how to find out which combinations of simple events have to be wired up into complex events. Which complex events stay at the basis of the mid frequency algos? How to scout for them?

Well, I didn’t graduate Paul Wilmott’s CQF. I cannot tell you that. I am a simple romanian finance bachelor, possibly going to be fried very soon in the coming mess to the public sector where I sadly work. I gave a minor suggestion about the mechanics of this search, in the article about self-tuning systems. If you got the brains and the power to go forward, and if you believe in the face value of the things, fairness of education and other blah blah stuff – try getting yourself a Computational Finance masters – or a Quantitative Finance masters – should be opening enough. If you can’t finance one, try Finland. I see Hanken is pretty fair – if you have the nerve to pass thru papers and questions. Otherwise, study alone, implement at home – with all the limits coming from this!

File links:
CEPEngine.mqh
ceptest.mq5

Combinatorics in MQL5

Bogdan Caramalac, MQLmagazine sr.editor — Mon, 24 May 2010 21:28:41 +0000

[Versiunea romaneasca] [MQLmagazine.com in romana] [English edition]

Long time ago I wrote on my former blog about generation of permutations, however I never dwelved too much into explaining the algorithm and the code. Indeed, there are situations when combinatorics are to be applied – when scouting for arbitrages or while deploying statistics requiring asset selections as prerequisite.

Permutations

Permutations are quite simple to both find and generate, although math manuals quite skip these algorithms. Since permutations are specific orders in which elements of a set are arranged, that means while arranging the elements, the possibilities to arrange the remainder elements shrink. For instance if we have 4 elements in a set, after setting the first we have just 3 places left, and so on, until the last element fits automatically to the single place left. Thus, the composition of the number depicting the permutation number is done like when composing a number in another numeration base, except that the base shrinks at every step.

For instance we have to find this permutation’s number:

|1|2|3|4|
|1|4|2|3|

At the beginning, the numeration base is 4, and our array is empty:

|1|2|3|4| : mathematical notation of positions
|1|4|2|3| : permutation to decypher

|0|0|0|0| : occupied places in the array
|0|1|2|3| : places in the array (zero-based)
|0|1|2|3| : count array

We look on the first position, 1, and read the first element, “1″. For computing reasons we use zero-based arrays.
Permutation number = 1-1 = 0

|1|2|3|4| : mathematical notation of positions
|1|4|2|3| : permutation to decypher

|0|0|0|0| : presently occupied places in the permutation
|1|0|0|0| : occupied places in positions notation after insertion
|0|1|2|3| : count array (conceptual, for counting)
|x|0|1|2| : new count array for remainder elements

Now we look at the second element. The second element reads “4″. Then, as we have just 3 seats free, the numeration base is 3. Permutation number = (0 x 3) = 0. To this, we add the position in the count array for the element “4″, which is 2 : Permutation number = 0 + 2 = 2

|1|2|3|4| : mathematical notation of positions
|1|4|2|3| : permutation to decypher

|1|0|0|0| : presently occupied places in the notation of positions
|1|0|0|4| : occupied places in positions notation after insertion
|x|0|1|2| : count array
|x|0|1|x| : new count array for remainder elements

Now we look at the third element. The third element reads “2″. Then, as we have just 2 seats free, the numeration base is 2. Permutation number = (2 x 2) = 4. To this, we add the position in the count array for the element “2″, which is 0 : Permutation number = 4 + 0 = 4

|1|2|3|4| : mathematical notation of positions
|1|4|2|3| : permutation to decypher

|1|0|0|4| : presently occupied places in the notation of positions
|1|2|0|4| : occupied places in positions notation after insertion
|x|0|1|2| : count array
|x|x|0|x| : new count array for remainder elements

Calculation stops. We need only to insert in calculation n-1 elements. The nth element is presumed to be on the leftover place.

Final permutation number = 4

The reverse algorithm, to generate permutations from permutation numbers, is the following:
Starting from base 2, we do n-1 steps of dividing the previous result by an increasing base, keeping the remainder.
So we have:
4 / 2 = [2], remainder 0
[2] / 3 = 0, remainder 2
[0] / 4 = 0, remainder 0

Then we start building the permutation back. We read the last remainder, and we find it to be 0. This means our first element is indeed “1″, as 0 from the count array stands for 1 in the positions array.

|1|2|3|4| : mathematical notation of positions
|0|1|2|3| : physical subscripts in array variable
|0|1|2|3| : count array
|1|0|0|0| : occupied positions after current element insertion
|x|0|1|2| : new count array for remainder elements
|1|0|0|0| : built permutation

Our base shrinked to 3, as we have 3 seats left. We read the following remainder, in a reversed order, and we find it to be 2. Looking into the new count array, we see that 2 corresponds to element “4″ from the mathematical notation.

|1|2|3|4| : mathematical notation of positions
|0|1|2|3| : physical subscripts in array variable
|x|0|1|2| : count array
|1|0|0|4| : occupied positions after current element insertion
|x|0|1|x| : new count array for remainder elements
|1|4|0|0| : built permutation

Our base shrinked to 2, as we have 2 seats left. We read the following remainder, in a reversed order, and we find it to be 0. Looking into the new count array, we see that position 0 corresponds to element “2″ from the mathematical notation.

|1|2|3|4| : mathematical notation of positions
|0|1|2|3| : physical subscripts in array variable
|x|0|1|x| : count array
|1|2|0|4| : occupied positions after current element insertion
|x|x|0|x| : new count array for remainder elements
|1|4|0|2| : built permutation

We have only last element to be determined, and that is “3″, on the single free seat unoccupied.

|1|2|3|4| : mathematical notation of positions
|0|1|2|3| : physical subscripts in array variable
|x|x|0|x| : count array
|1|2|3|4| : occupied positions after current element insertion
|x|x|x|x| : new count array for remainder elements
|1|4|3|2| : built permutation

Because both algorithms are quite straight, they can be implemented straight into functions. Thus, we are starting to write the Combinatorics.mqh.

//+------------------------------------------------------------------+
//|                                                Combinatorics.mqh |
//|                                       Copyright Bogdan Caramalac |
//|                                           http://mqlmagazine.com |
//+------------------------------------------------------------------+
#property copyright "Copyright Bogdan Caramalac"
#property link      "http://mqlmagazine.com"
 
//*************************************************
 
 string Replicate(string s, int count)
   {
    string res="";
    if (count<=0)
      return(res);
    for (int i=1;i<=count;i++)
      StringConcatenate(res,res,s);
    return(res);
   }
 
 int MathDiv(int a,int b)
    {
     int res;
     res=a-MathRound(MathMod(a,b));
     res=MathRound(res/b);
     return(res);
    }
 
 int Round(double a)
    {
     return(MathRound(NormalizeDouble(a,0)));
    }
 
//*************************************************

Usual stuff that we don’t insist on, we go forward to Permutations:

//********************************************************************
//
//
//                             Permutations
//
//
//********************************************************************
 
 long Factorial(ushort n)
   {
    long res=1;
    for (int i=2;i<=n;i++)
       res=res*i;
    return(res);
   }
 
 int FindPermutation(ushort elem, int& perm[])
    {
     int res=0;
     int rr;
     int positions[30];
     for (int i=0;i<ArrayRange(positions,0);i++)
        positions[i]=i+1;
     for (int e=1;e<elem;e++)//we don`t look for the last element , there is one seat left
        {
         rr=0;
         for (int i=0;i<elem;i++)
            {
             if (perm[e-1]==i+1)
               {
                res=res+rr;//has already -1, it`s zero-based
                //Print("Found element ",perm[e-1]," to be on perm[",i,"]. Adding ",rr, " to res, equals ",res);
                if (e!=elem-1)
                  res=res*(elem-e);
                //Print("Multiplicating by elem-e (",elem-e,") = ",res);                
                positions[i]=-1;
               }
             else
               { //if the searched element is not on current element,
                 //increment place counter only current position was not previously used;
                if (positions[i]!=-1)
                  rr++;
               }
            }
        }//for (int e=1;i<=elem;i++)
      return(res);  
    }
 
void GeneratePermutation(int number,int elem,int &perm[])
    {    
    string elemallow; 
    int stoppoint,crtpoint;       
    ushort AscX=StringGetCharacter("X",0);
    int i,j,base;
    int nnow;
    elemallow=Replicate("a",20);
    base=2;    
    nnow=number;    
    for (i=elem-2;i>=0;i--)
       {
       perm[i]=Round(MathMod(nnow,base));       
       nnow=MathDiv(nnow,base);
       base=base+1;        
       }
    perm[0]=perm[0]+1;//because first element is from 1 to elem, not 0 to elem-1    
    for (i=0;i<=elem-2;i++)
       {
       if (i==0)
         {
          StringSetCharacter(elemallow,perm[0]-1,AscX);
         }             
       else
          {
          stoppoint=perm[i]+1;          
          crtpoint=0;
          for (j=0;j<elem;j++)
             {             
             if (StringGetCharacter(elemallow,j)==AscX)
                continue;
             else
                {
                crtpoint=crtpoint+1;
                if (crtpoint==stoppoint)
                   {
                   perm[i]=j+1;//write new perm[i]
                   StringSetCharacter(elemallow,j,AscX);
                   }                   
                }
             }//for (j=0;j
          }//else if (i=0)    
        }//for (i=0;i
    for (i=1;i<=elem;i++)
       {
       if (StringGetCharacter(elemallow,i-1)!=AscX)
          {          
          perm[elem-1]=i;          
          break;
          }
       }        
    return;  
    }

This time we got lucky. Just two simple functions to call. Won’t be the case for Combinations.

Combinations

The combinations algorithm is way harder to understand than the permutations algorithm. The most used algorithm is the one that generates combinations in a recursive manner.

Let’s look at a simple combination queue: C(5,3)

1, 2, 3
1, 2, 4
1, 2, 5
1, 3, 4
1, 3, 5
1, 4, 5

First of all, every element has a different freedom degree. For instance, first can’t be beyond n-k+1.
Another thing, is that after you generate the first element, what you have to do then are C(n-1,k-1).
For instance, C(4,2) are:

1, 2
1, 3
1, 4
2, 3
2, 4
3, 4

For each instance of these , C(3,1) are:

1
2
3

Now you can see how it integrates:

When the procedure is called to generate C(5,3) it starts enumerating the first element, from 1 to 3. Thus, it has:

1,(1+x)

Then it calls itself to generate C(4,2) , starts enumerating from 1 to 2.
1,(1+1),(2+x)

Finally calls itself to generate C(3,1) , and completes:
1,2,(2+1) = 1,2,3
1,2,(2+2) = 1,2,4
1,2,(2+3) = 1,2,5

Returns to the previous cycle and continues with C(4,2) with the following element, 2:
1,(1+2),(1+2+x)

Starts calling C(3,1) and completes
1,3,4
1,3,5

Then turns back to continue C(5,3) with the following element, 2.

The algorithm continues until first function call ends the enumeration loop.

The implementation of the algorithm is quite murky. This time we opted for a class. Because, since direct generation is not possible, it’s not feasible to generate all the combinations every time you want a certain combination, in the case when you may want some from a list. So, a class is needed, to provide an inner loop generating the combinations while calling a callback function to pass the user the found combinations, with the option of early terminating.

//********************************************************************
//
//
//                             Combinations
//
//
//********************************************************************
 
 
long CombinationsTotal(ushort n,ushort k)
  {
   return(Factorial(n)/(Factorial(k)*Factorial(n-k)));
  }
 
class CombinationObject
  {   
   protected: 
   long counter;
   ushort n,k;
   bool terminate;   
   ushort current_combination[];
   private:
   ushort last_combination[];
   bool found;
 
   long CombinationsTotal(ushort n,ushort k);
   string CombImage(ushort &ccomb[],ushort n);
   void GenCombinationsRec(ushort depth,ushort nn,ushort kk);
 
   public:
   void SetupCombinationObject(ushort nn,ushort kk); 
   void LoopCombinations();
   virtual void CombinationsCallback();
   CombinationObject() {SetupCombinationObject(6,3);};   
  };
 
void CombinationObject::CombinationsCallback()
  {
   Print(CombImage(current_combination,k));
  }
 
void CombinationObject::SetupCombinationObject(ushort nn,ushort kk)
  {
   n=nn;
   k=kk;
   terminate=false;
   ArrayInitialize(current_combination,0);
   ArrayInitialize(last_combination,0);
   ArrayResize(current_combination,n);
   ArrayResize(last_combination,n);
   counter=0;
  }
 
string CombinationObject::CombImage(ushort &ccomb[],ushort n)
  {
   string res="";
   for (int i=0;i<n;i++)
      res=res+DoubleToString(ccomb[i],0)+" ";
   return(res);
  }
 
void CombinationObject::GenCombinationsRec(ushort depth,ushort nn, ushort kk)
  {
   bool okay,r;
   if (terminate==true)
     return;
 
   if (depth==k)
     return;  
 
   if (kk==0)
     return;
 
   int allows=nn-kk+1; 
   for (ushort i=1;i<=allows;i++)
      {
       if (terminate==true)
          return;
       if (depth==0)
         current_combination[depth]=i;
       else
         current_combination[depth]=current_combination[depth-1]+i;
 
       GenCombinationsRec(depth+1,nn-i,kk-1);
 
       okay=false;//checking for identical combination
       for (int j=1;j<=k;j++)
          {
           if (current_combination[j-1]!=last_combination[j-1])
             okay=true;//okay, new one
          }
       if (okay==false)
         continue;
       else
         { //copying current to last
          for (int j=1;j<=k;j++)
             last_combination[j-1]=current_combination[j-1];
         }
 
       CombinationsCallback();
       if (terminate==true)
         return;      
       counter=counter+1;
 
      }//for (int i=1;i<=allows;i++)
   return;
  }
 
void CombinationObject::LoopCombinations()
  {
   GenCombinationsRec(0,n,k);
   return;
  }

This is a way tougher nut to crack. The interesting function here, the engine itself, is GenCombinationsRec(). The depth parameter tells the function on which level it starts generating the combinations. When depth is depleted, that is, at every end of subsequent call queue, a new combination is generated in current_combination[] and counter is increased. What the user has to do, is to inherit this class in a custom class and override the CombinationsCallback(). Also, the terminate variable is available, if that is set to true, once the CombinationsCallback() ends, all GenCombinationsRec() calls will be early terminated and program will resume execution.

Arrangements

Since arrangements are permutated combinations, there is no point in overcomplicating the issue. The class is almost a carbon copy of the CombinationObject class, with the difference that the recursive method here, GenArrangementsRec(), which is quite like GenCombinationsRec(), generates combinations, and then, when every one of them is ready, permutates it and serves every arrangement (permutated combination) to the ArrangementsCallback(). Simple and convenient, yet results are not in the sorted manner like with Permutations and Combinations:

//********************************************************************
//
//
//                             Arrangements
//
//
//********************************************************************  
 
long ArrangementsTotal(ushort n,ushort k)
  {
   return(Factorial(n)/Factorial(n-k));
  }
 
class ArrangementObject
  {
   protected: 
   long counter;
   ushort n,k;
   ushort current_arrangement[];
   bool terminate;  
   private:
   ushort current_combination[];  
   ushort last_combination[];     
   bool found;
 
   long ArrangementsTotal(ushort n,ushort k);
   string ArrgImage(ushort &ccomb[],ushort n);
   void GenArrangementsRec(ushort depth,ushort nn,ushort kk);
 
 
   public:
   void SetupArrangementObject(ushort nn,ushort kk); 
   void LoopArrangements();
   virtual void ArrangementsCallback();
   ArrangementObject() {SetupArrangementObject(6,3);};   
  };
 
void ArrangementObject::ArrangementsCallback()
  {
   Print(ArrgImage(current_arrangement,k));
  }
 
void ArrangementObject::SetupArrangementObject(ushort nn,ushort kk)
  {
   n=nn;
   k=kk;
   terminate=false;   
   ArrayInitialize(current_arrangement,0);
   ArrayInitialize(current_combination,0);
   ArrayInitialize(last_combination,0);
   ArrayResize(current_combination,n);
   ArrayResize(current_arrangement,n);
   ArrayResize(last_combination,n);   
   counter=0;
  }
 
 
 
string ArrangementObject::ArrgImage(ushort &ccomb[],ushort n)
  {
   string res="";
   for (int i=0;i<n;i++)
      res=res+DoubleToString(ccomb[i],0)+" ";
   return(res);
  }
 
void ArrangementObject::GenArrangementsRec(ushort depth,ushort nn, ushort kk)
  {
   int perm[30];
   bool okay,r;
   if (terminate==true)
     return;
 
   if (depth==k)
     return;  
 
   if (kk==0)
     return;
 
   int allows=nn-kk+1; 
   for (ushort i=1;i<=allows;i++)
      {
       if (terminate==true)
          return;
       if (depth==0)
         current_combination[depth]=i;
       else
         current_combination[depth]=current_combination[depth-1]+i;
 
       GenArrangementsRec(depth+1,nn-i,kk-1);
 
       okay=false;//checking for identical combination
       for (int j=1;j<=k;j++)
          {
           if (current_combination[j-1]!=last_combination[j-1])
             okay=true;//okay, new one
          }
       if (okay==false)
         continue;
       else
         { //copying current to last
          for (int j=1;j<=k;j++)
             last_combination[j-1]=current_combination[j-1];
         }
 
 
       //here combination is final and arrangements are generated       
       for (int iperm=0;iperm<Factorial(k);iperm++)
          {
           GeneratePermutation(iperm,k,perm);           
           for (int jperm=0;jperm<k;jperm++)
              {
               current_arrangement[jperm]=current_combination[perm[jperm]-1];                              
              }                      
           ArrangementsCallback();                        
           if (terminate==true)
             return;      
           counter=counter+1;   
          }   
 
       }//for (int i=1;i<=allows;i++)
   return;                   
  }
 
void ArrangementObject::LoopArrangements()
  {
   GenArrangementsRec(0,n,k);
   return;
  }

And now a sample script (combtest.mq5). The script will display arrangements of n forex pairs taken as k, with a rising k, from 3 to n. Forex pairs are extracted at the beginning, by interogating each tradeable instrument about its calculation mode and retaining only the ones answering SYMBOL_CALC_MODE_FOREX , with the specification that symbol has to have 6 or more letters (two forex pairs and a suffix). Pairs are extracted and added to an array. Then a customized arrangements engine is called to display arrangements:

//+------------------------------------------------------------------+
//|                                                     combtest.mq5 |
//|                                       Copyright Bogdan Caramalac |
//|                                           http://mqlmagazine.com |
//+------------------------------------------------------------------+
#property copyright "Copyright Bogdan Caramalac"
#property link      "http://mqlmagazine.com"
#property version   "1.00"
 
 
#include 
 
int CurrenciesCount;
int PairsCount;
string ForexPairs[100];
 
//our class: we needed it to override ArrangementsCallback;
class LocalArrgClass : public ArrangementObject
  { 
    void ArrangementsCallback()
     {
      string image="";
      image=DoubleToString(counter,0)+" :";
      for (int i=0;i<k;i++)         
         image=image+" "+ForexPairs[current_arrangement[i]-1];
      Print(image);      
     }   
  };
 
//the arrangment object
LocalArrgClass myarrg;
 
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
 
void CheckAndAddPair(string pair)
  {
   bool found;
   if (PairsCount==0)
     {
      ForexPairs[PairsCount]=pair;
      PairsCount++;
     }
   else
     {
      found=false;
      for (int i=0;i<PairsCount;i++)
         {
          if (ForexPairs[i]==pair)
            {
             found=true;
             break;
            }          
         }
      if (found==false)
        {
         ForexPairs[PairsCount]=pair;
         PairsCount++;               
        } 
     } 
   return;
  }
 
void OnStart()
  {  
   string crtsymbol,pair1,pair2;
   CurrenciesCount=0;
   PairsCount=0;
   for (int i=0;i<SymbolsTotal(false);i++)
      {
       crtsymbol=SymbolName(i,false);
       if (SymbolInfoInteger(crtsymbol,SYMBOL_TRADE_CALC_MODE)==SYMBOL_CALC_MODE_FOREX&&StringLen(crtsymbol)>=6)
         {          
          pair1=StringSubstr(crtsymbol,0,3);          
          CheckAndAddPair(pair1);
          pair2=StringSubstr(crtsymbol,3,3);         
          CheckAndAddPair(pair2);
         }
      }//for (int i=0;i
    for (int iarrg=3;iarrg<=PairsCount;iarrg++)
       {
        myarrg.SetupArrangementObject(PairsCount,iarrg);
        myarrg.LoopArrangements();      
       }
  }
//+------------------------------------------------------------------+

Here’s a peek on how it looks (though you have to stop it using terminate – otherwise it will jump some of the log):

You might ask why did we opted for permutations to use int instead of uint or long. The answer is the MathMod() and MathRound() issue. These functions don’t work with integer types. Even if they expect and return an integers as meaning they still work with double as type. So any convertions have to rely on a force cast of a double, which is a signed real type, as int is a signed integer type. Using unsigned integers or even longer long types that span over 8 bytes instead of just 6 like double would have overcomplicated the issue. I think these functions have to be re-engineered by MetaQuotes, to work only with integer types and to abide the received integer types that play the operands, just as div and mod work in Pascal implementations. And as for MathRound() , this must be a real rounding function that returns in the integer type that is to receive the result, or in a generic integer type, if it is used in expressions.

File links:
Combinatorics.mqh
combtest.mq5

DLL Hell, MQL5 edition : UNICODE vs ANSI

Bogdan Caramalac, MQLmagazine sr.editor — Wed, 31 Mar 2010 19:33:41 +0000

[Versiunea romaneasca] [MQLmagazine.com in romana] [English edition]

Many many years ago, when we were kids, in the beginning years of the crazy 90s, two languages were in battle in developer world. Pascal, with a down-to-earth, easy to understand syntax, well suited to a high level language, and C++, with a more cryptic, but faster to use syntax, well suited to its medium level. C++ won the battle, and everything that was done in Windows became compiled in C++ and beared its marks : null-terminated strings and what was known at that time as standard calling convention.

The null-terminated strings were normal strings, known as ANSI strings, but at that time there was no UNICODE yet. Every character was a single byte and the strings had a dynamic lenght, as they were supposed to end with a null (a zero byte). Thus applications were receiving a pointer to indicate were to read these strings from, and knew where the strings end, by looking for a zero byte. As for the standard calling convention, on procedure call, C++ compiler was pushing parameters on the stack starting from the last and finishing with the first.

Null-terminated string (ANSI)

|---------------|
|c1|c2|....| 0  |
|b1|b2|....|bn+1|
|---------------|

Pascal was the absolute reverse of C++ in all these matters. Strings were ANSI too, one byte per each character, but strings had a fixed length of 255 bytes, or compiler defined. They had an extra byte in the front, specifying the logical length of the string (how many bytes were actually used). As for the calling convention, this was perfectly reversed, as in the pascal calling convention parameters were pushed on the stack from the first to the last.

Standard Pascal string (ANSI)

|------------------|
|ln|c1|c2|....|c255|
|b1|b2|b3|....|b256|
|------------------|

This is why Pascal strings could have been sent entirely to functions, without the need to send by reference, which is the unique mode that string sending is possible in C++.

As C++ won the battle, Pascal compiler had to adapt, and calling convention was an easy task. As for the strings, the problem became complicated, as developers had to struggle with PCHAR, a name given to fixed arrays of one byte per element, which were supposed to hold C++ null-terminated strings and were sent by reference.

As these were not enough for developers, the UNICODE standard came in.

UNICODE is a complicated standard, and I don’t know it entirely. The difference from the ANSI is that UNICODE characters are wider, generally they span on two bytes each, but there are also 4-byte character coded strings. In the beginning, UNICODE strings seemed to be something new and awckward. Thus, they were called wide strings. Windows API Functions working with wide strings were had a name terminated with W ; pointers to null-terminated ANSI strings were char* , thus pointers to null-terminated UNICODE had to be called wchar_t* .

Null-terminated strings (UNICODE)

|------------------------------------------|
|  c1 |  c2 |....|      cn   |      0      |
|b1|b2|b3|b4|....|b 2n-1|b 2n|b 2n+1|b 2n+2|
|------------------------------------------|

MQL5, as most of the programming environments nowadays, is UNICODE. Even simple strings that you use regularly are still UNICODE. They have an ANSI look, but internal representation is UNICODE. This is because ANSI can be packed in UNICODE, filling unneed bytes with 0.

ANSI packaged in UNICODE (MQL5 normal strings)

|------------------------------------------|
|  c1 |  c2 |....|      cn   |      0      |
|b1|0 |b3|0 |....|b 2n-1| 0  |b 2n+1|  0   |
|b1|b2|b3|b4|....|b 2n-1|b 2n|b 2n+1|b 2n+2|
|------------------------------------------|

So, in a UNICODE-packed ANSI, every even byte is 0.
But what if you have an older C++ DLL, who uses null-terminated ANSI strings ?
That means it expects and returns null-terminated ANSI strings.

So, if you are to send an “ABC” string to such a DLL, it have mapped in bytes: 65, 0, 66, 0, 67, 0.
The DLL will see the first 0 as the null terminating the string and will understand only “A” from the entire string.

If you are to receive an “ABC” from this type of DLL, you would receive in bytes: 65, 66, 67, 0.
The UNICODE MQL5 will understand first character as 65 and 66 (making something chinese-like), and the second character as 67 and 0, mapping to “C”. Then it will continue reading, if there is no access violation, until it finds 0 and 0, making up for the null, resulting in a complete jabber. The access violation might be avoided because MT5 might allocate enough space for string receival.

Sadly, MQL5 doesn’t have an ansistring type to handle conversions automatically. But, for the good part, at least in both cases strings are sent by reference, so it is actually a problem of meaning instead of a conflict in value/reference sending.

This means you have to send UNICODE strings that are to be correctly decoded as ANSI, and receive in ANSI strings that you have to convert to UNICODE for using.

When you are to receive an ANSI string in a UNICODE form, start reading UNICODE characters by typecasting each character to a unsigned short, then divide this in the two ANSI, (by modulo 256), add to resulting UNICODE string the modulo (as ANSI code), and the remainder (as ANSI code). So each 2 bytes of the original ANSI map into 4 bytes (2 UNICODE characters).

When you want to pack an ANSI-encoded UNICODE string, like an MQL5 string, as an ANSI, you read every two UNICODE chars in a row, then forcibly typecast them to unsigned char, like the size of ANSI characters. Then pack up new UNICODE character with the first read as modulo and second as remainder into a larger unsigned short, that you will add as code of the new character to the resulting UNICODE string.

The following is the code of two conversion functions, written as a include file. Make sure you make this file to be a include file, in the include folder, saving it as stringlib.mqh.

//+------------------------------------------------------------------+
//|                                                    stringlib.mqh |
//|                                       Copyright Bogdan Caramalac |
//|                                           http://mqlmagazine.com |
//+------------------------------------------------------------------+
#property library 
#property copyright "Bogdan Caramalac"
#property link      "http://mqlmagazine.com"
#property version   "1.00"
 
string ANSI2UNICODE(string s)
  {
   ushort mychar;
   long m,d;
   double mm,dd;
   string img;    
   string res="";
   if (StringLen(s)>0)
     {
      string g=" ";
      for (int i=0;i<StringLen(s);i++)
         {          
          string f="  ";          
          mychar=ushort(StringGetCharacter(s,i));
          mm=MathMod(mychar,256);
          img=DoubleToString(mm,0);
          m=StringToInteger(img);
          dd=(mychar-m)/256;
          img=DoubleToString(dd,0);
          d=StringToInteger(img);
          if (m!=0)
            {
             StringSetCharacter(f,0,ushort(m));
             StringSetCharacter(f,1,ushort(d));
             StringConcatenate(res,res,f);
            }//if (m!=0)
          else
            break;                      
         }//for (int i=0;i
      }//if (StringLen(s)>0)
   return(res);
  }
 
string UNICODE2ANSI(string s)
  {
   int leng,ipos;
   uchar m,d;
   ulong big;
   leng=StringLen(s);
   string unichar;
   string res="";
   if (leng!=0)
     {    
      unichar=" ";
      ipos=0;      
      while (ipos<leng)
        { //uchar typecasted because each double byte char is actually one byte
         m=uchar(StringGetCharacter(s,ipos));
         if (ipos+1<leng)
           d=uchar(StringGetCharacter(s,ipos+1));
         else
           d=0;
         big=d*256+m;                
         StringSetCharacter(unichar,0,ushort(big));         
         StringConcatenate(res,res,unichar);    
         ipos=ipos+2;
        }
     }
   return(res);
  }

When using the include you simply write

#include

as in the following example:

//+------------------------------------------------------------------+
//|                                                  teststrings.mq5 |
//|                                       Copyright Bogdan Caramalac |
//|                                           http://mqlmagazine.com |
//+------------------------------------------------------------------+
#property copyright "Bogdan Caramalac"
#property link      "http://mqlmagazine.com"
#property version   "1.00"
 
#include 
 
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
   string original_unicode,ansi,converted_unicode;
   original_unicode="EvenString";
   ansi=UNICODE2ANSI(original_unicode);
   converted_unicode=ANSI2UNICODE(ansi);
   Print(original_unicode," -> ",ansi," -> ",converted_unicode);
   original_unicode="OddString";
   ansi=UNICODE2ANSI(original_unicode);
   converted_unicode=ANSI2UNICODE(ansi);
   Print(original_unicode," -> ",ansi," -> ",converted_unicode);
  }
//+------------------------------------------------------------------+

MQL5 : Connecting to MySQL

Bogdan Baltatu, MQLmagazine editor — Wed, 31 Mar 2010 19:33:25 +0000

[Versiunea romaneasca] [MQLmagazine.com in romana] [English edition]

This article is dedicated to sending data from MQL5 to a MySQL database. The article is at the same time an example for the functions presented in the article DLL Hell, MQL5 Edition : UNICODE vs ANSI.
The main advantages of collecting data in MySQL databases would be : data interrogration, lower space needed for important quantities of data. For instance the trades stored in a database occupy probably less than an equivalent HTML file. However, the main disadvantage is that such export is being done to analyse data on another platform or on manually written platforms, that need development time and are error prone – either to conception errors or to programming errors.

First you need to have installed the MySQL server and a connector. In order for the code to work you have to allow dll import from the platform and put the libmysql.dll library in the ‘libraries’ folder. We had a problem with a 64 bit edition of a libmysql.dll . Dependancies issues, probably even import (normally a 32-bit application can’t import 64-bit dlls). To get rid of the problems brought by a 64-bit dll we recommend to use one for 32-bit based systems.

//+------------------------------------------------------------------+
//|                                                 Mysql-Sample.mq5 |
//|                                          Copyright Bogdan Baltatu|
//|                                           http://mqlmagazine.com |
//+------------------------------------------------------------------+
#property copyright "Bogdan Baltatu"
#property link      "http://mqlmagazine.com"
#property version   "1.00"
 
#include 
 
#import "libmysql.dll"
   int mysql_init(int db);
   int mysql_errno(int TMYSQL);
   int mysql_real_connect(int TMYSQL, string& host, string& user, string& password,
                           string& DB,int port,int socket,int clientflag);
   int mysql_real_query(int TMYSQL,string& query,int lenght);
   void mysql_close(int TMSQL);                        
   string mysql_error(int TMYSQL); //string is ansi
#import
 
string MySqlHost   ="localhost"; //MySql Host:
string MySqlUser   ="user";     //MySQL User:
string MySqlPass   ="passpass";      //MySQL Password:
string MySqlDB     ="forex";     //MySQL Table:
int    MySqlPort   =3306;        //MySQL Port:
string MySqlSocket ="";          //MySQL Socket:
input int    MySqlFlag   =0;           //MySQL Flag:
int mysql   =0;
string query="";
MqlTick tick;
 
 
 
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
 
int OnInit()
  {
   string host,user,pass,DB;
   if(MQL5InfoInteger(MQL5_DLLS_ALLOWED)==0)
      {
        Alert("DLL calling not allowed. Allow and try again!");
      }
   mysql=mysql_init(0);
   Print("obiectul mysql=",mysql);
   host=UNICODE2ANSI(MySqlHost);
   user=UNICODE2ANSI(MySqlUser);
   pass=UNICODE2ANSI(MySqlPass);
   DB=UNICODE2ANSI(MySqlDB);
   int res=mysql_real_connect(mysql,host,user,pass,DB,MySqlPort,MySqlSocket,MySqlFlag);
   Print("connection result=",res);
   if (res==mysql)
      Print("Successfully connected to the MySQL server!");
   else
     { 
      string s;
      s=mysql_error(mysql);     
      Print("Eroare de conectare = ",ANSI2UNICODE(s));
      return(0);
     } 
   //Create table
   StringConcatenate(query,"CREATE TABLE IF NOT EXISTS ",_Symbol," (time VARCHAR(30) ,BID double,ASK double)");
   sql_query(query);
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   mysql_close(mysql); //Close connection
   return;
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   SymbolInfoTick(_Symbol,tick);
   StringConcatenate(query,"INSERT INTO ",Symbol()," (time,ask,bid) VALUES ('",tick.time,"',",tick.ask,",",tick.bid,")");
   sql_query(query);
   return;
  }
//+------------------------------------------------------------------+
void sql_query(string _query)
  {
    string ansiquery;
    int length=StringLen(_query);
    ansiquery=UNICODE2ANSI(_query);
    mysql_real_query(mysql,ansiquery,length);
    int mysqlerr=mysql_errno(mysql);
    if (mysqlerr>0)
      {
       Print("Query: ",_query);
       Print("Returned error: ",ANSI2UNICODE(mysql_error(mysql)) );       
      }      
    return;
  }

Between lines 9 and 17 we declare the functions that we import from libmysql.dll . Being an example we imported just 6 functions. For a deeper study of these functions use the mysql documentation.

Working with files. Part IV

Bogdan Baltatu, MQLmagazine editor — Wed, 31 Mar 2010 19:33:08 +0000

[Versiunea romaneasca] [MQLmagazine.com in romana] [English edition]

This article is the last from the ‘Working with files’ series and it will treat the file reading functions exclusively. Functions that deal with file reading are :

1 2	FileReadArray(), FileReadBool(), FileReadDatetime(), FileReadDouble(), FileReadFloat(), FileReadInteger(), FileReadLong(), FileReadNumber(), FileReadString(), FileReadStruct()

FileReadArray()

The function reads from a binary file arrays of any type except for string. The function’s prototype is:

uint  FileReadArray(
 int  file_handle                            // File handle
 void  array[],                              // Array to record
 int   start_item=0,                       // start array to write
 int   items_count=WHOLE_ARRAY    // items count
);

The function parameters are : the file handle, the array being recorded in, the position where reading begins and the number of elements to be read. The result is the number of read elements.

Code example:

double b[];
int fh=FileOpen("test.bin",FILE_BIN|FILE_READ|FILE_WRITE);
FileWriteDouble(fh,5.123);
FileWriteDouble(fh,1.2123);
FileSeek(fh,0,SEEK_SET);
FileReadArray(fh,b,0,WHOLE_ARRAY);
FileClose(fh);

I preferred to write in the binary file using the FileWriteDouble() function (lines 3 and 4) when I could have used the FileWriteArray() function, because I wanted you, the reader, to play with the code and get the conclusion which I present here.

On the line 5 I called the function FileSeek() because If I would read immediately, the cursor would be at the end of the file and function wouldn’t have read anything , so before using the FileReadArray() you have to be sure the position of the cursor is in the right place.

The type of the array must be the same with the type of the elements we wish to read. If for instance we wrote in the file with FileWriteDouble(), the array where data must get by FileReadArray() must be double. If it’s not, the data will be altered according to the type of the b array ; in our case the function reads sets of 8 bytes each, because a double spans over 8 bytes.

Write an element with FileWriteDouble() and one with FileWriteInteger() and make the read in a double typed array to see what happens. After you do this you’ll draw the conclusion that is better than in a file to keep only one type of function for writing and the array or the structure where you read to be the same type as written elements.

Be careful about the cursor’s position!
I remind you that the first element in an array is on the 0 position, so in our case the first will be b[0] and the secondary will be b[1].

FileReadBool()

The function’s prototype is

1
2
3

bool  FileReadBool(
   int  file_handle    // File handle
   );

The function reads in a CSV typed file a string and converts to boolean.
Functia citeste dintr-un fisier CSV un string si il converteste in boolean; false for 0, true for anything else.

FileReadDatetime()

The function reads from a CSV file a string in one of the formats: “YYYY.MM.DD HH:MI:SS”, “YYYY.MM.DD” or “HH:MI:SS” and converts them in a datetime value. The function’s prototype is:

datetime  FileReadDatetime(
 int  file_handle    
);
 
The function has just one parameter and that is the file handle retrieved by FileOpen().
 
Code example.
 
<pre lang="mql5">int fh=FileOpen("test.csv",FILE_CSV|FILE_READ|FILE_WRITE);
FileWrite(fh,"asd 12:54 06:00");
FileSeek(fh,0,SEEK_SET);
datetime dt=FileReadDatetime(fh);
FileClose(fh);

Note that on line 2 I wrote in the same string two substrings that can be interpreted and converted as date (“12:54″ and “06:00″). The function reads always the first string that can be converted to date from the current cursor position and converts it in a variable of datetime type.

If our date is HH:MM then dt would take the value : “YYYY.MM.DD 12:54″ where YYYY.MM.DD is the current date.

FileReadDouble()

The function reads a double from the current cursor position in a binary file. The function’s prototype is:

1
2
3

double  FileReadDouble(
 int  file_handle    
);

The function has a single parameter and that is the file handle returned by FileOpen() and the function’s result is a double.

Code example:

 int fh=FileOpen("test.bin",FILE_BIN|FILE_READ|FILE_WRITE);
FileWriteDouble(fh,1.1234);
FileWriteDouble(fh,0.0123);
FileSeek(fh,8,SEEK_SET);
double dvalue=FileReadDouble(fh); 
FileClose(fh);

I wrote two double typed values in the file. If we ‘play’ with the second parameter of the FileSeek() function, we will observe that the numbers differs from the typed one because the function reads 8 bytes from the cursor position and the number returned by FileReadDouble() will be different from the what’s written.

FileReadFloat()

The function reads a float from a binary file. The function’s prototype is:

1
2
3

float  FileReadFloat(
 int  file_handle
);

The function has a single parameter and that is the file handle retrieved by FileOpen().

Code example:

int fh=FileOpen("test.bin",FILE_BIN|FILE_READ|FILE_WRITE);
FileWriteFloat(fh,0.3f);
FileSeek(fh,0,SEEK_SET);
float fvalue=FileReadFloat(fh);
FileClose(fh);

Same note as above: beware the cursor’s position!!

FileReadInteger()

The function reads and integer, short or char from the current pointer position according to the specified bytes length. The function’s prototype is:

int  FileReadInteger(
 int  file_handle         // File handle
 int  size=INT_VALUE      // Size of an integer in bytes
);

The function’s parameter are the file handle retrieved by FileOpen() and the number of bytes to be read from the current cursor position. (1 for char, 2 for short, 4 for int).

Exemplu de cod:

 int fh=FileOpen("test.bin",FILE_BIN|FILE_READ|FILE_WRITE);
FileWriteInteger(fh,15867,4);
FileSeek(fh,0,SEEK_SET);
int ivalue=FileReadInteger(fh,4);
FileClose(fh);

Even if I repeat myself one more time : beware at the cursor position and the number of bytes to be read!
Chiar daca ma repet mai adaug o data : atentie la pozitia cursorului si atentie la numarul de bytes pe care il citim.

FileReadLong()

The function reads a long integer (8 bytes) from the current position of a file opened as binary. The function’s prototype is:

1
2
3

long  FileReadLong(
 int  file_handle    
);

The function has only one parameter, the file handle returned by FileOpen().

Code example:

<pre lang="mql5"> int fh=FileOpen("test.bin",FILE_BIN|FILE_READ|FILE_WRITE);
FileWriteInteger(fh,15867,8);
FileSeek(fh,0,SEEK_SET);
int ivalue=FileReadLong(fh);
FileClose(fh);

FileReadNumber()

The function reads from a CSV file a string from the current position until it finds the separator then converts the string in a double.
The function’s prototype is:

1
2
3

double  FileReadNumber(
 int  file_handle    
);

The function has a single parameter and that is the file handle returned by FileOpen().

Code example:

int fh=FileOpen("test.csv",FILE_CSV|FILE_READ|FILE_WRITE);
FileWrite(fh,1.2);
FileSeek(fh,0,SEEK_SET);
double dvalue=FileReadNumber(fh);
FileClose(fh);

If on line 2 we would have had “A”, then FileReadNumber() would have returned 0.

FileReadString()

The function reads from a string at the current position. The function has the following prototype:

string  FileReadString(
 int  file_handle      
 int  size=-1          
);

The function has as parameters : file_handle, which is the returned by FileOpen() and size which is the number of characters that we wish to read.

Code example:

 int fh=FileOpen("test.bin",FILE_BIN|FILE_READ|FILE_WRITE);
FileWriteString(fh,"abcdef");
FileSeek(fh,0,SEEK_SET);
string svalue=FileReadString(fh,3);

If we open the file as text, the secondary parameter is not mandatory, because the FileReadString() function will read until the end of the line marker (‘\r\n’). Also it’s not mandatory for the case file is opened as CSV, because the function will read until it finds the separator.

FileReadStruct()

The function reads the from a binary file into a structure, starting with the current pointer position. The function’s prototype is:

uint  FileReadStruct(
 int                file_handle      //File handle
 any_simple_struct  str_object,      // Structura that receives data
 int                size=-1          // Size of structure in bytes
);

Code example:

int fh=FileOpen("test.bin",FILE_BIN|FILE_READ|FILE_WRITE);
MqlRates w[1],r[1];  
CopyRates(Symbol(),PERIOD_D1,0,1,w);
int so=sizeof(w[0]);
uint s=FileWriteStruct(fh,w[0],so);
FileSeek(fh,0,SEEK_SET);
FileReadStruct(fh,r[0],so);
FileClose(fh);

I’d like to note that from MetaEditor build 252 the FileWriteStruct() and FileReadStruct() functions work exclusively with structures, before that were supporting arrays too. In older versions you could have written for instance “FileWriteStruct(fh,a,so)” but now line is reported with error (“a – invalid access array”).

Accessing Market Data in MQL5

Bogdan Baltatu, MQLmagazine editor — Sun, 28 Feb 2010 19:55:55 +0000

[Versiunea romaneasca] [MQLmagazine.com in romana] [English edition]

In this article I’ll present the functions that access market data in MQL5, and I’ll compare tot the function that was doing this in MQL4.

In MQL4 there was a unique function that was the holder of all the market information, and that was MarketInfo(). In MQL5 the MarketInfo() function vanished, being replaced by SymbolInfoDouble(), SymbolInfoInteger(), SymbolInfoString(), SymbolInfoTick(). The name of the function is being formed from 3 words: the first two are ‘SymbolInfo’ and the last word is the one showing what the function returns, ‘Double’, ‘Integer’ or ‘String’.

SymbolInfoDouble()

The function has two prototypes:

double  SymbolInfoDouble(
   string  name,      // symbol   
   int     prop_id     // identifier of the property     
);

The second prototype is:

bool  SymbolInfoDouble(
   string   name,      // symbol    
   int      prop_id,    // identifier of the property     
   double &double_var // here we assume the property value
);

The function returns true if the function is successful (if it places the returned value in a variable sent as parameter).

Identifier	Description	MQL4 Equivalent
SYMBOL_BID	Bid – Best buy offer (level II) or price to sell at (level I)	MODE_BID
SYMBOL_BIDHIGH	Maximal Bid of the day	None
SYMBOL_BIDLOW	Minimal Bid of the day	None
SYMBOL_ASK	Ask – Best sell offer (level II) or price to buy at (level I)	MODE_ASK
SYMBOL_ASKHIGH	Maximal Ask of the day	None
SYMBOL_ASKLOW	Minimal Ask of the day	None/td>
SYMBOL_LAST	Price of the last deal	None
SYMBOL_LASTHIGH	Maximal Last of the day	None
SYMBOL_LASTLOW	Minimal Last of the day	None
SYMBOL_POINT	Mathematic point. For instance, if a quotation has 4 digits, the point is 1/10000.	MODE_POINT
SYMBOL_TRADE_TICK_VALUE	The value of a tick, on the standard lot, in the currency of the account. For instance is 1 at EURUSD, if the lot is 100000, with 5 digits, or 10, for 4 digits. For forex, is CONTRACT SIZE * TICK SIZE, considered in the second currency in the pair and converted in the account currency. For futures, is CONTRACT SIZE * POINT * TICK SIZE (should be also converted in the currency of the account, but this may be missing…)	MODE_TICKVALUE
SYMBOL_TRADE_TICK_SIZE	The size of a tick. For forex, it is the same as POINT. For other markets, it differs. For instance it is 0.25 for corn futures, because that is the minimum quoting step.	MODE_TICKSIZE
SYMBOL_TRADE_ CONTRACT_SIZE	The size of one lot (the standard lot). Usually, for forex is 100000 units (for some brokers, beware, it’s 10000). Differs for futures.	MODE_LOTSIZE
SMBOL_VOLUME_MIN	Minimal volume for a deal	MODE_MINLOT
SYMBOL_VOLUME_MAX	Maximal volume for a deal	MODE_MAXLOT
SYMBOL_VOLUME_STEP	Step of the volume (the acceptable volume is a multiple of the step, starting with the minimal volume)	MODE_LOTSTEP
SYMBOL_SWAP_LONG	Long swap value	MODE_SWAPLONG
SYMBOL_SWAP_SHORT	Short swap value	MODE_SWAPSHORT

SymbolInfoInteger()

Functia are acelasi prototip ca functia SymbolInfoDouble().

Tabelul de echivalenta a functiei SymbolInfoInteger() in MQL4 este:

Identifier	Description	Type	MQL4 Equivalent
SYMBOL_SELECT	Symbol is selected in Market Watch	bool	None
SYMBOL_VOLUME	Volume of the last deal	long	None
SYMBOL_VOLUMEHIGH	Maximal day volume	long	None
SYMBOL_VOLUMELOW	Minial day volume	long	None
SYMBOL_VOLUMEBID	Volume for current Bid	long	None
SYMBOL_VOLUMEASK	Volume for current Ask	long	None
SYMBOL_TIME	Time of the last quote	datetime	MODE_TIME
SYMBOL_DIGITS	Number of decimals after the point (or base 10 logarithm of the reverse of POINT)	int	MODE_DIGITS
SYMBOL_SPREAD	Spread value in points	int	MODE_SPREAD
SYMBOL_TICK_BOOKDEPTH	Ticks storing depth	long	None
SYMBOL_TRADE_CALC_MODE	Contract profit and margin calculation mode	ENUM_ SYMBOL_ CALC_ MODE	None
SYMBOL_TRADE_MODE	Order execution type	ENUM_ SYMBOL_ TRADE_ MODE	None
SYMBOL_TRADE_STOPS_LEVEL	The minimum distance between the current price and the Stop level	int	MODE_STOPLEVEL
SYMBOL_TRADE_FREEZE_LEVEL	Order freeze level in points. If the execution price lies within the range defined by the freeze level, the order cannot be modified, cancelled or closed.	int	MODE_FREEZELEVEL
SYMBOL_TRADE_EXEMODE	Deal execution mode	ENUM_ SYMBOL_ TRADE_ EXECUTION	None
SYMBOL_SWAP_MODE	Swap calculation model	ENUM_ SYMBOL_ SWAP_ MODE	MODE_SWAPTYPE
SYMBOL_ROLLOVER3DAYS	The day the swap is triple	ENUM_ DAY_OF_ WEEK	None

The ENUM_SYMBOL_CALC_MODE type describes the calculus mode for margin and profit, as follows:

Identifier	Description	Formula
SYMBOL_CALC_MODE_FOREX	Forex	Margin: LotsContract_Size/Leverage; Profit: (close_price-open_price)Contract_Size*Lots
SYMBOL_CALC_MODE_CFD	CFD	Margin: Lots ContractSizeMarketPricePercentage/100; Profit: (close_price-open_price)Contract_Size*Lots
SYMBOL_CALC_MODE_FUTURES	Futures	Margin: Lots InitialMarginPercentage/100 Profit: (close_price-open_price)TickPrice/TickSizeLot
SYMBOL_CALC_MODE_CFDINDEX	Indice CFD	Margin: (LotsContractSizeMarketPrice)TickPrice/TickSize; Profit: (close_price-open_price)Contract_Size*Lots
SYMBOL_CALC_MODE_CFDLEVERAGE	CFD cu levier	Margin: (LotsContractSizeMarketPricePercentage)/Leverage; Profit: (close_price-open_price)Contract_Size*Lots;

The ENUM_SYMBOL_TRADE_MODE type describes what kind of operations are allowed.

Identifier	Meaning
SYMBOL_TRADE_MODE_DISABLED	Trade is disabled fro the symbol
SYMBOL_TRADE_MODE_LONGONLY	Allowed only long positions
SYMBOL_TRADE_MODE_SHORTONLY	Allowed only short positions
SYMBOL_TRADE_MODE_CLOSEONLY	Allowed only position close operations
SYMBOL_TRADE_MODE_FULL	No trade restrictions

The ENUM_SYMBOL_TRADE_MODE type describes what manner is the execution.

Identifier	Meaning
SYMBOL_TRADE_EXECUTION_REQUEST	Execution by request.
SYMBOL_TRADE_EXECUTION_INSTANT	Instant execution
SYMBOL_TRADE_EXECUTION_MARKET	Market execution

While Deviation remains a crucial parameter for execution, the difference between the three modes remains to be seen.

The ENUM_SYMBOL_SWAP_MODE describes how swaps are applied.

Identifier	Meaning	Notes
SYMBOL_SWAP_MODE_DISABLED	Swap mode disabled (no swaps)
SYMBOL_SWAP_MODE_BY_POINTS	Swaps in points
SYMBOL_SWAP_MODE_BY_MONEY	Swaps in money, its value is specified in the symbol properties in the deposit currency	Probably swap in the account currency, for the standard lot
SYMBOL_SWAP_MODE_BY_INTEREST	Swaps in yearly percents (bank mode – 360 days in a year)	The formula is pretty clear, but which is the currency?
SYMBOL_SWAP_MODE_BY_MARGIN_CURRENCY	Swaps in money, its value is specified in the symbol properties in the margin currency	Probably swap in the margin currency, for the standard lot.

However, MetaQuotes didn’t indicate also the calculus formulas. The swap was a real mystery in MT4, and the formulas where found out by trial and error (except for type 2, which remained undiscovered by me in the 2007 article on swaps). Seems however this time swaps will be easier to extract, without the headaches from MT4.

The ENUM_DAY_OF_WEEK type has the week days, as the name states.

SymbolInfoString()

The function has the same prototype SymbolInfoDouble.

The MQL4 equivalence table of the SymbolInfoString() function:

Identifier	Description	MQL4 equivalent
SYMBOL_CURRENCY_BASE	Basic currency of a symbol	None
SYMBOL_CURRENCY_PROFIT	Profit currency	None
SYMBOL_CURRENCY_MARGIN	Margin currency. For forex, it’s the first currency in the pair.	None
SYMBOL_BANK	Feeder of the current quote	None
SYMBOL_DESCRIPTION	Symbol description	None
SYMBOL_PATH	Path in the symbol tree	None

SymbolInfoTick()

The SymbolInfoTick() function has the following prototype.

bool  SymbolInfoTick(
   string    symbol,     // symbol
   MqlTick&  tick        // reference to a MqlTick structure
   );

The function fills an MqlTick structure with the data of the current quote.

Working with files. Part III

Bogdan Baltatu, MQLmagazine editor — Sun, 28 Feb 2010 19:45:15 +0000

[Versiunea romaneasca] [MQLmagazine.com in romana] [English edition]

This is the third article of the ‘Working with files’ series and I care to announce you that this is one of the most important articles of the series because I’ll present the writing functions as well as examples that will show some aspects of the functions.

The functions that refer strictly file writing are 8. These functions are:

1 2	FileWrite() , FileWriteArray() , FileWriteDouble() , FileWriteFloat() , FileWriteInteger() , FileWriteLong() , FileWriteString() , FileWriteStruct()

In the continuation I’ll present each function with its notes.

FileWrite()

The function is used for writing data in CSV files. The prototype of the function is:

uint  FileWrite(
   int  file_handle    // file handle
   ...                 // List of parameters to be written
   );

The file_handle parameter represents the result of the FileOpen() function, that has to be called with the flags FILE_CSV|FILE_WRITE. If the file is not open with the FILE_WRITE flag, then FileWrite() will fail.

The parameter list to be written in the CSV file cannot be larger than 63, parameters will be separated by the delimiter specified when we opened the file with the FileOpen() function. Should we have not specify it at that time, the ‘tab’ delimiter would have been default (ASCII 9).
The parameter type is not specified, they could be integer, datetime , float , … . It is important to know that the FileWrite() function converts the parameters in strings. The double parameters have 16 digits after the decimal dot, the float parameters have 5, and the datetime parameters are converted to the ‘YYYY.MM.DD HH:MI:SS’.
Each FileWrite() command puts at the end of the generated string ‘\r\n’. This shows us that after writing the string the cursor moves to the next row.

1 2	int file_handle=FileOpen("text.csv",FILE_ANSI\|FILE_CSV\|FILE_WRITE); uint chars_written=FileWrite(file_handle,1,3,4,5,6,7);

In Excel 2007, even if delimiter is ‘tab’ and the parameters should be displayed on a separate column they don’t show up. If we rename the file to ‘.txt’ and we open it with Excel 2007 then parameters will be each on a column because it admits the ‘tab’ character. The issue is not with Excel and it deserves some study. It is recommended to open the CSV with an editor as notepad or notepad++ if it has more than 65535 lines.

FileWriteArray()

The function writes elements of different types of array, except for the string ones, in files opened as FILE_BIN.

The prototype of the function is:

int  FileWriteArray(
int   file_handle                   
void  array[],                     
int   start_item=0,             
int   items_count=WHOLE_ARRAY   
);

The parameters of the function are file_handle , the result of the FileOpen(); array , the array that is source for the elements to be written in the file; start_item , position in the array where to start writing from; items_count , the number of elements to be copied starting from start_item.

The result of the FileWriteArray() function is the number of elements written in the file, so the result of the function has to be equal to items_count for the function call to be considered successfully.

If the table has 9 elements and we send an items_count larger than 9, the FileWriteArray() will not return any error, because it will write all the 9 elements.

Below you have a code example which writes a matrix in a binary file (opened with FILE_BIN):

1
2
3

double array1[3][3]={{1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0}};
int file_handle=FileOpen("text.bin",FILE_BIN|FILE_WRITE);
int elements_written=FileWriteArray(file_handle,array1,0,WHOLE_ARRAY);

String arrays have to be written in TXT files. Each element, when written in the file, is followed by the ‘\r\n’ characters, so each table element is written on a new line. Below we exemplified in a code sample the functionality of FileWriteArray() if the matrix is string.

1
2
3

string array1[3][3]={{"a", "b", "c"}, {"d", "e", "f"}, {"g", "h", "i"}};
int file_handle=FileOpen("text.txt",FILE_TXT|FILE_WRITE|FILE_ANSI);
int elements_written=FileWriteArray(file_handle,array1,6,3);

FileWriteDouble()

The function writes in a file from the current cursor position a value of the double type. The function’s prototype is:

uint  FileWriteDouble(
   int     file_handle      
   double  dvalue           
   );

Parameters are two: file_handle is the file handle returned by FileOpen() and dvalue is the double value that we wish to have it written in the file.

The function is considered successful if the result is 8, meaningly the length in bytes of a double type variable, and the pointer moves by 8 bytes.

Below is a code example.

1 2	fh=FileOpen("test.bin",FILE_WRITE\|FILE_BIN); s=FileWriteDouble(fh,a);

Warning: To use the FileWriteDouble() function, the file has to be opened binary, otherwise the function fails.

FileWriteFloat()

The FileWriteFloat() function resembles FileWriteDouble() , only that the variable to be written is of float type. The function’s prototype is:

uint  FileWriteFloat(
int    file_handle      
float  fvalue           
);

The function parameters are file_handle , the reference of the file given by FileOpen() and the float value that we wish to have it written in our file.

Code example.

1 2	fh=FileOpen("test.bin",FILE_WRITE\|FILE_BIN); s=FileWriteFloat(fh,a);

Of course, the result has to be 4, the length in bytes of a float type variable, for a correct writing.

FileWriteInteger()

The function writes an integer typed variable in a binary file beginning from the current pointer. The function's prototype is:

uint  FileWriteInteger(
int  file_handle         
int  ivalue,              
int  size=INT_VALUE 
);

The parameters of the function are : the file handle, the value that we wish to have written, and its length in bytes.
The last parameter may be 1, 2 or 4 (1=char , 2=short, 4=integer).
The function returns 1,2 or 4 accordingly to the size parameter and the returned value has to be equal with this, if the execution was correct.

Code example:

1
2
3

int a=2;
   fh=FileOpen("test.bin",FILE_WRITE|FILE_BIN);
   s=FileWriteInteger(fh,a,4);

The file has to be opened as binary, otherwise the function fails. If the function is correctly executed then pointer moves with as much bytes as the function returns (1, 2 or 4).

We have to specify that by 'int' in the function's prototype the compiler actually understands any integer type, and the function does not automatically presume signed integers, being able to work with unsigned integers.

FileWriteLong()

The function writes a long typed value ion a binary file beginning with the current cursor position in the file. The function's prototype is:

uint  FileWriteLong(
int   file_handle      
long  lvalue           
);

The parameters of the function are : the file handle, returned by the FileOpen() call and the value that we want to have written. If the function executes successfully, it returns 8, the length in bytes of a long typed variable.

Code example

1
2
3

long a=212313123;
fh=FileOpen("test.bin",FILE_WRITE|FILE_BIN);
s=FileWriteLong(fh,a);

FileWriteString()

The function writes a string in text or binary file beginning with the current position of the cursor. The function's prototype is:

uint  FileWriteString(
   int     file_handle      
   string  svalue,         
   int     size=-1          
   );

The parameters of the function are : the file handle, the string that we want to have written, and the number of characters contained by the string.
The third parameter is mandatory if the file has been opened with FILE_BIN, but optional when the file has been opened as FILE_TXT.

If the execution is successful then the result is the number of bytes written in the file and the cursor's position moves by this number of bytes.

It should be noted that when we use the function to write in a FILE_UNICODE file (specified or not, because FILE_UNICODE is default), the number of bytes written is twice the number of characters. When we write with FILE_ANSI flag, the number of bytes is the same as the number of characters. MetaQuotes' decision is a bit awkward , to make FILE_UNICODE default instead of FILE_ANSI. It should be normal that FILE_ANSI is default,
De precizat ar fi ca atunci cand folosim functia pentru a scrie intr-un fisier deschis cu FILE_UNICODE (specificat sau nu, caci FILE_UNICODE e default) numarul de bytes scrisi este de 2 ori mai mare decat numarul de caractere. Cand scriem cu flagul FILE_ANSI numarul de bytes scrisi coincide cu numarul de caractere. E cel putin ciudata decizia MetaQuotes sa faca FILE_UNICODE default in loc de FILE_ANSI. Normal ar fi ca FILE_ANSI sa fie default, to avoid the useless doubling of the text files, being known that the majority of users will open them with Notepad or Excel.

Code example.

1
2
3

 string a="A1b2C3";
fh=FileOpen("test.txt",FILE_WRITE|FILE_ANSI);
s=FileWriteString(fh,a);

FileWriteStruct()

The function writes in a binary typed file the contents of a structure parsed as parameter beginning with the current cursor position. The prototype of the function is:

uint  FileWriteStruct(
int                file_handle     
any_simple_struct  str_object&,   
int                size             
);

The function parameters are : the file handle returned by FileOpen(), the structure (by reference) and the length in bytes that has to be written. If the function is executed successfully it returns the number of written bytes.

Code example:

 MqlRates a[1];  
CopyRates(Symbol(),PERIOD_D1,0,1,a);
int so=sizeof(a);
fh=FileOpen("te.bin",FILE_WRITE|FILE_BIN);   
s=FileWriteStruct(fh,a,so);

When we define the structure 'a', we have to define it as array, to be able to use it with the CopyRates() function, and it has to have at least one element.

It should be known that the files opened with FILE_BIN where we wrote something will contain weird characters if opened. They are not wrongly written. Even if the files are binary we saved them as '.txt' to be easily to be opened with the text editor for you to see easier that something was written.

It seems that MetaQuotes has chosen a complicated path for files. I'll make a short review on how Borland Pascal knew files, so you can see how simple was at that time (the '90s).
First, Borland Pascal didn't have the concept of file handle, a number to identify the file. It had only file typed variables. These were complex variables, known only by compiler - they couldn't have been read, written or interogated. The functions that dealt with reading/writing were about 6 : ReadLn, WriteLn, Read, Write, BlockRead, BlockWrite. ReadLn and WriteLn were working only with the screen, keyboard and text files, while Read and Write were also working on the "binary" level. Due to the special nature of the file variables, Read and Write knew from the beginning if they have an I/O operation with keyboard/screen or with a file. There was no need of FileRead or FileWrite, because if the first parameter was a file typed variable, it couldn't have been mistaken with an integer or anything else - the functions knew from beginning what they work with. If it was file of text , and you were writing Write(f,128) , the function would have written "128", text, on 3 characters, and if the file would have been file of byte, the function would have written a byte with the 128 value.
Also, the strict definition of variables made the difference between types and functions knew from beginning how many bytes they had to read/write for any data type. If file had a complex type , like file of record (record was the equivalent for struct from MQL5), then functions were reading or writing one by one many structures in a row, incrementing the cursor with the number of structures, not with the number of bytes. BlockRead and BlockWrite were working with any kind of variables, being interested only in the length of the read/written blocks (they were working with untyped files).

Be careful when using file functions. Otherwise, you can lose time recording data that are saved in a wrong manner!