MQLmagazine.com » Programarea in MQL

Linii directoare pentru scrierea expertilor de portofoliu in MQL5

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

[English version] [MQLmagazine.com in english] [Editia romaneasca]

Expertii de portofoliu, la fel ca si expertii multiasset, mai complecsi, au fost asteptati de comunitatea de retail trading de cand limitarile backtesterului MT4 au devenit evidente, adica de acum 4 – 5 ani. Diferenta intre expertii multiasset si cei de portofoliu e ca expertii multiasset au o strategie integrata in care fiecare activ e o componenta, in vreme ce expertii de portofoliu replica aceeasi strategie, cu unele diferente parametrice, pe mai multe instrumente. Bineinteles, in contextul MT4, expertii normali puteau fi rulati pe instrumente separate in vederea obtinerii efectelor de portofoliu,
dar backtestingul n-ar fi putut niciodata acoperi aceste efecte de portofoliu pentru ca nu se putea face backtest pe mai mult decat pe un instrument.

Avantajul principal al portofolizarii este impingerea rezultatului spre medie concomitent cu imprastierea riscului. Gradul insa pana la care aceasta se intampla, e dependent de corelatia de ansamblu a portofoliului. Cu cat acest grad este mai mic, cu atat riscul nesistematic ramas de acoperit este mai mic. Totusi, daca nu alegi portofoliul cum trebuie, in loc sa aduca echilibru sistemului de trading pe ansamblu, va adauga instabilitate.

Un sistem de trading pe un portofoliu trebuie sa:
- aplice o logica similara de trading la un numar mare de active;
- diferentieze logica de trading de la un instrument la altul;
- controleze expunerea.

E nevoie de o structura de date destul de mare pentru a face lucrurile controlabile:

De exemlu, aceasta:

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

Prima variabila, MarginUsagePerPosition e un fel de parametru de alocare a activelor, controland volumul maxim pe fiecare pozitie. SymbolsCount va spune cate simboluri sunt folosite si pot fi folosite pentru enumerare, iar tabela mare SymbolsTable[] va contine datele necesare, de la simboluri pana la handlere. De exemplu, urmatoarea structura va calcula 4 medii mobile (doua pe M5 si doua pe H1) pentru fiecare simbol.

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

Inainte de OnInit() trebuie sa scriem o procedura care sa umple SymbolsTable[] cu handlerele indicatorilor.
MakeIndicatorHandlers() este apelata din OnInit() pentru a separa setupul simbolurilor de setupul indicatorilor.
Astfel poti modifica usor OnInit() pentru a schimba lista, prin adaugare, stergere sau introducerea unui selector automat de instrumente, dar MakeIndicatorHandlers() va ramane neschimbat, cu scopul de a umple structura cu handlerele necesare pentru indicatori.

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

In interiorul OnInit(), setam tabela simbolurilor. De exemplu, o facem sa mearga cu trei perechi forex: EURUSD, USDCHF, GBPJPY:

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

Si acum 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;
  }

Acum toate piesele sunt complete. OnTick() va verifica pentru fiecare instrument daca o noua bara a aparut si va apela TradeLogics() pentru fiecare instrument din tablou, care va implementa decizia si tradingul.

Nu ne vom opri asupra TradeLogics() in acest articol, pentru ca TradeLogics() e specific fiecarui EA. Dar cateva principii trebuie sa fie ghid la scrierea TradeLogics(). Prima diviziune a TradeLogics() este clasa de active cu care lucreaza. Nu poate lucra cu actiuni cum lucreaza cu forex. Actiunile nu se tranzactioneaza 24 de ore zi, 5 zile pe saptamana. Au sesiuni specifice si salturi pe chart de la o zi la alta, ca sa nu mai zic de la o saptamana la alta. A doua, e aceea ca e mai bine sa separam functiile de trading de TradeLogics(). De exemplu, TradeLogics() poate comanda cum sa se ajusteze pozitia pentru un anumit instrument, lasand functia de tranzactionare procedurii ManagePosition(). Bineinteles, TradeLogics() poate fi lansat in practica si de OnTrade() sau OnChartEvent(), poate chiar si de metoda EventsCallback() a unui motor CEP.

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() este o portare a unei functii pe care am scris-o in vremurile MQL4, si care functiona la acea vreme cu MarketInfo(). UnitsToLots() va intoarce numarul de loturi ce corespunde unui volum dat in unitati. De exemplu poate raspunde 1.0 pentru 100000 unitati pe 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);
    }
  }

Aceasta functie este un proxy simplu pentru a obtine un raspuns clar privind tipul unei pozitii. Valoarea pentru POSITION_TYPE_BUY este 0 in MQL5, iar PositionInfoInteger() va raspunde 0 chiar daca pozitia nu a fost selectata inainte de apelare.

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

Ce face ManagePosition() ? Deschide o pozitie pentru activul dat prin index, la cerere, daca este inchisa dinainte (mai bine zis, “aplatizata”) ; sau inverseaza pozitia curenta, prin calcularea noii marime a lotului (o calculeaza cu formula, adauga la volumul curent si inverseaza operatiunea). Poate adauga sau taia din pozitia curenta. Parametrul forcevolume poate fi folosit pentru a forta un anumit volum a fi tranzactionat, sarind calculul. Ce parere ai de un stop loss ? Nimic mai usor:

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

De observat ca apelurile la OrderSend() nu sunt urmate de o analiza a rezultatului. Nu ne-am scufundat in analiza codurilor de intoarcere pentru ca unele dintre ele nu sunt complet clare.

Si in final OnDeinit(), care distruge handlerele indicatorilor.

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 : Un expert demonstrativ de portofoliu folosind medii mobile

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

[English version] [MQLmagazine.com in english] [Editia romaneasca]

Am scris acest expert ca o demonstratie completa privind scrierea expertilor de portofoliu, urmarind principiile prezentate in Linii directoare pentru scrierea expertilor de portofoliu in MQL5.

Expertul va lucra pe timeframe-ul ales, numai cand o bara noua se formeaza pe fiecare instrument participant. Dupa verificarea intersectiilor de medii mobile, va administra pozitiile. Exista si optiunea de a filtra dupa volatilitate (am reparat indicatorul BBoverSTD din articolul Analiza volatilitatii : de la previziunea volatilitatii la previziunea pretului).

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

Aceasta sectiune defineste constantele pentru lucrul cu pozitii (FLAT,LONG,SHORT) si parametrii sistemului.

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

Aceasta sectiune defineste structura de date care retine simbolurile si handlerele indicatorilor.

void MakeIndicatorHandlers()
  {
   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;
  }

Aceasta este procedura MakeIndicatorHandlers() adaptata nevoilor acestui expert.

Acum urmeaza UnitsToLots(), GetPositionType(), PositionSetSLTP() si ManagePosition() care sunt cele prezentate in Linii directoare pentru scrierea expertilor de portofoliu 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);
  }

Aceasta intoarce semnalul mediei mobile pentru activul solicitat. Semnalul poate fi “L”,”S” sau “-”.

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

Aceasta este TradeLogics(). Mai intai verifica daca VolatilityFilter e activat, si numai in acest caz apeleaza indicatorul BBoverSTD, pentru a face economie de timp in situatia in care filtrul este dezactivat. Apoi testeaza daca avem pozitie inchisa. Daca da, cumpara sau vinde dupa semnalul MASignal(), eventual filtrat de valorile BBoverSTD, daca VolatilityFilter e activat. Daca avem pozitie lunga sau scurta deja, verifica aparitia unui semnal contrar (desigur, cu aceeasi filtrare). Daca un semnal contrar vine, pozitia este inchisa, altfel nu are loc nicio adaptare a pozitiei la noul capital (desi ManagePosition() o poate face, nu i se cere).

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

Acesta este OnInit(). Este deja setat sa lucreze cu 4 perechi valutare. Daca SymbolsCount ramane 1, numai EURUSD va fi tranzactionat. Daca il setezi la 4, toate cele patru perechi vor fi tranzactionate. Poti modifica SymbolsTable[] dupa dorinta (probleme pot aparea totusi la tranzactionarea CFD-urilor datorita metodei de calcul a lotului). OnInit() trebuie sa se incheie cu un apel la MakeIndicatorHandlers() pentru a face indicatorii gata de utilizare.

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

Acesta este OnTick(). OnTick() contine ciclul de simboluri, si solicita timpul ultimei bare de pe timeframe-ul curent la simbolul curent dat de ciclu. Daca acest timp este diferit decat cel retinut, inseamna ca o noua bara a aparut pe acel chart. Apoi este apelat TradeLogics() pentru decizie si apel la 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;
  }

Acesta este OnDeinit(). Elibereaza handlerele indicatorilor. Daca OnInit() ar rula din nou, ar face alte handlere. Nu este complet necesar sa facem asta, dar risipirea memoriei cu handlere noi de fiecare data cand ruleaza OnInit() nu se poate numi programare curata.

Urmatoarele backtesturi au fost realizate fara StopLoss si TakeProfit, de asemenea si cu VolatilityFilter dezactivat.

Dupa cum se poate vedea, portofolizarea nu a fost o alegere buna. A adaugat instabilitate aditionala si caderi mai adanci. Totusi, acum avem de-a face cu sisteme de trading, in vreme ce teoria managementului portfofoliului presupune in general o strategie de tip “long or out”. De aceea, in teoria financiara, corelatiile negative scad riscurile, deoarece plusurile la unele active se compenseaza cu minusuri la altele. Dar, ceea ce avem acum e un portofoliu de sisteme de trading. Ne putem gandi la un sistem de trading ca o functie de equity a instrumentelor:

equity = sistem de trading(instrument)

Pe doua active corelate perfect negativ, functia sistem de trading va intoarce doua serii de equity corelate perfect pozitiv. O aplicare riguroasa ar cere ca o selectie Markowitz sau CAPM asupra sistemelor de trading sa fie facuta pe outputuri de sisteme de trading in loc sa fie facuta pe datele de piata.

Vezi de asemenea si articolul desprevirtualizarea sistemelor de trading, care priveste problema dintr-un alt punct de vedere.

Link:
PortfolioMA.mq5

Virtualizarea sistemelor de trading pentru ajustarea liniei de equity – un mit ?

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

[English version] [MQLmagazine.com in english] [Editia romaneasca]

Te-ai gandit vreodata cum ar fi sa ai o medie mobila pe linia de equity a unui sistem de trading, ca sa-l poti porni si opri ? Asta s-ar numi ajustarea liniei de equity.

Aspectul frustrant este acela ca odata ce incepi sa faci asta din sistemul de trading la care vrei sa ajustezi linia de equity, nu mai poti controla procesul, pentru ca indicatorii liniei de equity vor raporta diferit de fiecare data cand apesi pe buton.

Deci, ceea ce ai de facut e este sa lasi sistemul pe demo cumva in paralel cu sistemul de trading principal, sa copiezi tranzactiile in contul principal cand switchul e activat si sa le ignori cand switchul e dezactivat.

Aceasta se poate realiza prin virtualizare. Adica, trebuie sa scrii un sistem de management al pozitiilor , demo, ca un cont virtual, a carui iesire este “equity” catre sistemul de trading principal, care va optimiza aceasta curba si va decide daca va replica sau nu tranzactiile sistemului demo.

Astfel, incepem sa scriem un astfel de sistem, pe care-l vom numi 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;  
  };

Incepem cu definitiile obisnuite pentru managementul pozitiilor, urmate de doua structuri. Prima este proiectata pentru stocarea datelor refritoare la simboluri, oferind simbolul, pozitia (pozitiva – lunga, negativa – scurta), pretul (pretul la initializarea pozitiei), pretul marcat (ultimul pret la care pozitia a fost marcata la piata). A doua este proiectata pentru a stoca datele de equity virtuale : timpii de deschidere si inchidere pentru bara de equity; deschidere, maxim, minim, inchidere pentru fiecare equity din interval. Acum e timpul pentru clasa VirtualAccount.

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

Clasa contine un tablou de VirtualSymbolsData si numarul sau de elemente, si un tablou cu VirtualEquityData. Alti parametri cheie sunt VirtualLastEquityPos si VirtualEquityBarSpan (timpul pe care se intinde o bara, in secunde). VirtualLastAccountEquity este doar un proxy pentru ultima valoare inregistrata a 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() si VirtualGetPositionSize() sunt pur informationale. Marimea pozitiei e intotdeauna pozitiva, tot asa cum PositionInfoDouble() intoarce valorile pentru cererile POSITION_VOLUME. Celelalte doua functii fac exact ce spune numele lor ca face – seteaza stop loss si take profit.

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

La inceput, clasa este setata automat cu un equity egal cu cel al contului pe care lucreaza si o largime a barei in timp de 0. Userul poate seta de la inceput contul sa aiba un equity de inceput diferit, si o alta largime in timp a barei. La fiecare tick, VirtualMarkToMarket(-1) trebuie sa fie apelat pentru a ne asigura ca toate pozitiile sunt marcate la piata cu preturile noi. Inregistrarile in VirtualEquity[] incep de la 0. Daca distanta in timp nu este 0, si noul tick soseste in intervalul de la deschiderea barei, noul tick este inregistrat pe acea bara, campul de close, cu stampilarea campului closetime. Maximul si minimul equity per bara sunt recalculate.
At the beginning, the class is automatically set up with an equity equal to the real account equity and a timespan of 0. Daca intervalul e 0, sau daca noul equity soseste prea tarziu, se va inregistra pe bara urmatoare, pana la ultimul subscript (499). Cand trebuie sa intre pe 500, tabloul este impins spre stanga cu o pozitie si bara 499 incepe sa fie inregistrata de la inceput. VirtualAddNewEquity() este apelata numai din clasa. De aceea, a fost desemnata ca metoda private.

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() este inima intregii clase. Poate fi apelat pentru o pozitie sau pentru toate pozitiile. Marcheza pozitiile la piata, calculand equity. Pentru fiecare pozitie calculeaza fluctuatia in equity de la ultimul pret marcat pana la pretul curent, care devine pret marcat. Pentru aceeasi pozitie, procedura va sterge stop loss si take profit odata atinse. Userul trebuie doar sa apeleze VirtualMarkToMarket(-1) la fiecare tick pentru a marca la piata toate pozitiile.

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

Pentru a face o tranzactie, trebuie sa folosesti VirtualChangePosition(), care va deschide o pozitie in directia data, cu pretul si marimea lotului specificata, pe activul specificat prin index. Aceasta deschidere este similara deschiderii unei “afaceri” (deal). De aceea, numai ORDER_TYPE_BUY si ORDER_TYPE_SELL sunt suportate. Nu exista ordine pending sau StopLimit. Functia doar seteaza sau modifica pozitii. De asemenea elimina stop loss-ul sau take profit daca pozitia isi inverseaza semnul.

Acum ca am realizat clasa, e timpul sa virtualizam expertul pe medii mobile din articolul
MQL5 : Un expert demonstrativ de portofoliu folosind medii mobile, intr-un fisier nou, 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;

Variabilele sunt cam aceleasi, cu diferenta ca acum stop loss, take profit si noile perioade ale mediilor mobile se impart in doua : pentru contul virtual si contul pe care ruleaza sistemul efectiv.

#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";

Structurile sunt destul de similare. Clasa este instantiata in obiectul VirtualSystem. Timpul de deschidere al ultimei bare de equity este inregistrat in VirtualLastBarTime. Variabila RealTrading retine modul in care tranzactiile se copiaza din contul virtual in cel efectiv, si anume “STRAIGHT” (direct), “REVERSED” (invers), “FORBIDDEN” (interzis) (numai “STRAIGHT” si “FORBIDDEN” sunt utilizate efectiv).

VirtualMakeIndicatorHanders() ia locul lui MakeIndicatorHandlers(). Codul este la fel, doar numele este schimbat.

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

Aceasta este VirtualManagePosition. Opereaza ca ManagePosition() dar cererile ei sunt directionate catre contul virtual. La sfarsit, dupa ce analizeaza variabila RealTrading, decide sa nu faca nimic, sa replice identic sau inversat operatiunile din contul virtual in cel efectiv.

Functiile MASignal(), PositionSetSLTP() si ManagePosition() raman la fel ca in expertul original.

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

Acesta este fostul TradeLogics(), dar modificat pentru a opera in contul virtual.

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

Aceasta
This function is used in OnInit pentru a seta distanta in timp a barelor contului virtual – ea converteste perioadele in minute.

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

Acesta este OnInit(). Pregateste simbolurile la fel ca fostul OnInit() apoi copiaza simbolurile in contul virtual. Seteaza contul virtual si se asigura ca RealTrading e setat ca “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;
  }

Acesta este OnTick(). Ca si OnTick() precednt, are un ciclu de simboluri si aplica logica pentru fiecare simbol, de aceasta data pe contul virtual. Declara EquityCloseBuffer[] unde ultimele valori ale barelor de equity din contul virtual sunt copiate, dupa ce fiecare ciclu este inchis. Cand aces buffer are destule valori, o intersectie de medii mobile pe linia de equity a contului virtual este calculata. Cand aceaste medii mobile dau un semnal de crestere, RealTrading trece pe “STRAIGHT”. Portofoliul este replicat din contul virtual pe contul real, portofoliul este replicat din contul virutal pe contul efectiv, proportional cu marimea contului efectiv. Desigur, VirtualManagePosition() va apela la randul lui ManagePosition() , iar din acest moment ambele conturi vor functiona simultan. Cand semnalul mediilor mobile este de scadere, RealTrading este setat la “FORBIDDEN” iar pozitiile contului efectiv sunt inchise.

OnDeinit() este exact la fel, dupa cum handlerele indicatorilor rezida in aceeasi SymbolsTable[].

Surprins? Executia pe portofoliu este mai instabila decat cea pe o singura pereche, asa cum a fost si pentru sistemul de trading principal. Volatilitatea suplimentara se traduce in miscari in range ale equity, care se transforma in semnale false date de mediile mobile pe equity, facand ca virtualizarea sa fie un fiasco. Exista cel putin trei puncte care trebuie luate in consideratie.

1. Frecventa samplingului
Care este frecventa optima de sampling pentru media mobila pe equity? La urma urmei, nu stim exact cum MetaTrader comprima barele de equity deci nu stim nici macar intervalul lui de sampling. Atunci, cum sa stim sa extragem mostrele pentru medie?

2. Sistemul de trading optim pentru linia de equity
Nimeni n-a zis ca mediile mobile peste equity sunt cea mai buna cale de ajustare. Alte criterii se pot aplica, la fel ca in tradingul obisnuit.

3. Ar trebui sa tranzactionam toate instrumentele in acelasi cont virtual, sau in conturi virtuale separate si sa ajustam linia de equity pentru fiecare?

Concluzia principala care se extrage e ca sistemele de trading nu trebuie sa fie bazate pe o aplicare rece, pura, a indicatorilor. Indicatorii, asa cum le spune si numele, indica unele actiuni care trebuie luate, dar precum consilierii care dau sfaturi, influenteaza pozitiv rezultatele sistemelor de trading, dar locul lor nu trebuie sa fie in miezul acestora. Mai degraba, statistici riguroase si relatii de arbitraj sunt la baza sistemelor de trading eficiente.

Linkuri:
TradeVirtualization.mqh
VirtualPortfolioMA.mq5

MQL5 : Implementarea unui motor CEP simplu

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

[English version] [MQLmagazine.com in english] [Editia romaneasca]

Aceasta editie a fost mai dificil de facut decat editiile precedente. Lansarea tarzie a Strategy Tester si numarul mare de defecte iesite la iveala in timpul realizarii motorului CEP au consumat foarte mult timp. Din acest moment, editiile revistei nu vor mai fi lunare, pentru ca vor contine foarte multa munca si imbunatatiri ale unor lucrari mai vechi. De aceea, de aceasta data adaugam Forumul.

Acum inapoi la motorul CEP.

Motorul CEP a fost unul din cele mai dificile lucruri posibile de scris in MQL5. A fost dificil nu numai pentru mine ca programator, ci a avut implicatii si asupra MT5 de asemenea, intrucat structura intortocheata de date pe care o foloseste a pus MetaTrader la incercare ; a necesitat munca de remediere a defectelor, in special la obiecte si alocari de memorie. Codul a reusit sa functioneze cu probleme minore abia la build-ul 270 (da, deja in mai) si complet curat pe build 271. Este un cod lung si dificil, pe care il voi sparge in bucati pentru a-l comenta. Am pastrat comentariile de linie si liniile de Print pentru a fi mai bine inteles de cititori. Algoritmul este usor modicat, nu e exact cel prezentat in Anatomia unui motor CEP simplu .

Urmatorul fisier va fi denumit 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.");   
  }
 
//*******************************************

Acestea sunt functii string foarte simple, necesare pentru functiile mai mari care traduc structuri in mesaje string, descrieri ale structurilor CEP. Prima functie va replica un string, iar a doua va returna un string pentru o variabila logica, intr-un stil gen FoxPro.

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

Structura SimpleEvent este la miezul motorului. Coada de evenimente pe care am descris-o in articolul precedent este facuta din micute structuri SimpleEvent. EventID joaca rol de ID, EventTime este timpul (in ticksi – milisecunde de la pornirea Windows – nu formatul datetime), BindCount spune cator evenimente complexe este asociat evenimentul simplu, iar Binds[] contine aceste evenimente. Functiile BindEvent(), FindBind(), si UnbindEvent() sunt cele care lucreaza cu acesta structura. Normal, ar fi trebuit sa optez pentru o clasa in loc de structura, dar ce castigi in functionarea clasei pierzi in manevrabilitatea datelor : nu poti copia obiecte, decat camp cu camp, altfel primesti Structura are obiecte si nu poate fi copiata (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];
  };

Structura ComplexEvent este unitatea de baza a tabelei evenimentelor complexe. Va aduceti aminte imaginea din articolul precedent? Cam cuprinde ceea ce poate fi gasit in structura ComplexEvent. Astfel, avem ID-ul, constrangerea temporala, numarul de aranjamente (numarul de linii) sau versiuni ale cozilor de evenimente care constituie acelasi eveniment complex, si in final un tablou de aranjamente, constituit de mai multe SimpleEventArrangement.

Structura SimpleEventArrangement descrie ceea ce poate fi numita ca linie a matricii. Astfel, avem un contor si linia (adica EventArray[]) care contine evenimentele simple cerute. Tabloul Prebinds[] va nota, desigur, preasocierile acestor evenimente, adica pozitia in coada de evenimente simple care este gasita. NegationsCount[] va contine cate evenimente de negatie sunt cerute a nu aparea inainte de fiecare eveniment simplu care trebuie sa apara. Deci, un contor per fiecare eveniment simplu cerut. NegationsArray[] va contine evenimentele solicitate a nu aparea, pe coloane in loc de linii. NegationsChecked[] e un fel de tablou prescurtat de preasocieri. In loc sa stocheze locatiile negatiilor, un simplu steag este ridicat in acest tablou, pentru ca tabloul este 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;
  }

Functia MakeSimpleArrangement() va construi un aranjament de evenimente simple, dintr-un sir, asa cum e instruita de user. De exemplu, “10 !6 11″ inseamna “10, urmat de 11, dar 6 trebuie sa nu apara inainte de 11″. Bara de spatiu este separator, iar steagul de negatie poate fi “-”,”!”,”n” sau “N”. De notat ca inainte de sfarsit, datele sunt inversate, de la prima la ultima, dupa cum am spus in evenimentul precedent, iar aranjamentele de evenimente complexe vor incepe de la cele mai recente catre cele mai vechi, Aceasta functie nu trebuie sa fie apelata de utilizator, ci va fi apelata de 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;
  }

Functia MakeComplexEvent() trebuie sa fie apelata de utilizator cand spune motorului cum trebuie sa arate evenimentele complexe. Definitia este un sir mare cu mai multe evenimente simple, separate de punct si virgula. Alti parametri mai sunt ID-ul, constrangerea temporala si o variabila eveniment complex in care sa fie asezat rezultatul.

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

Aceasta functie a fost facuta numai din ratiuni de comentare. Functia descrie un eveniment complex intr-o forma sir. Poti scoate rezultatul pe ecran cu 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();
   };

In final, am ajuns si la clasa motorului CEP.
QueueTimeConstraint este o variabila importanta, care spune lungimea in timp pentru care motorul se va uita in coada. Evenimentele simple care sosesc, gasite in EventsQueue[] si care trec dincolo de “orizontul de timp” sunt suprascrise. OldestIndex este capatul tabloului ; este un capat dinamic, calculat la fiecare noua apelare RaiseEvent() din exterior, respectand QueueTimeConstraint, si are timpul, in ticksi, in OldestTime.

Acum lucrurile mici:

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

Deci, ClearEvents() goleste coada de evenimente simple. Aceasta este si ratiunea pentru care este apelata din constructorul CEPEngine(). AddComplexEvent() adauga un nou eveniment complex la tabela. Trebuie sa fie apelat de utilizator, dupa construirea evenimentelor cu MakeComplexEvent(). Motorul e gata de lucru numai dupa ce constrangerea temporala e setata de utilizator cu SetupEngineMilliseconds(). Si, in final, EventsCallback() este metoda virtuala care trebuie sa fie redefinita de utilizator, fiind apelata cand motorul CEP ridica un eveniment complex. Functia StatusString() produce o versiune comentariu a starii motorului.

Acum ceva mai complicat : RaiseEvent() : cand utilizatorul ridica un eveniment simplu

    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

Functia are un nivel moderat de complexitate.
Liniile 7 – 32 stabilesc orizontul de timp in interiorul cozii. Adica stabilesc care este cel mai vechi eveniment din coada care respecta constrangerea temporala a intregii cozi.
Liniile 33 – 38 misca coada cu un pas mai jos, facand loc pentru un nou eveniment simplu.
Line 74 – metoda EngineRun() este apelata pentru a procesa noile date, daca cel putin un eveniment complex este inregistrat in tabela.

Inima motorului CEP este metoda EngineRun().Este cea mai complicata piesa de cod din intreaga clasa. Dar, n-ar exista masina fara motor, nu ?

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

Functia consta in doua cicluri. Primul este ciclul principal, liniile 13 – 117, iar al doilea ciclu este 120 – 140. Al doilea ciclu are un rol de curatare care va fi explicat mai jos.

Primul ciclu va trece prin ComplexEventsTable, ca sa vada care evenimente complexe apar. Pentru fiecare eveniment complex din tabela, aranjamentele vor fi verificate, si pentru fiecare aranjament, o serie de proceduri vor fi indeplinite.
In interiorul acestui ciclu, alt ciclu va trece prin EventsQueue[], (liniile 23 – 115) de la primul la ultimul, uitandu-se dupa evenimente ce respecta constrangerea temporala a evenimentului complex curent. Una din cele mai importante variabile in acesta metoda este tabloul CrtColumn[]. Acesta stocheza pointerul curent (coloana curenta in tabloul unidimensional EventArray[]). Astfel, procedura verifica evenimentul simplu curent cerut de tabela cu cel gasit in coada (linia 26) , il preasociaza si incrementeaza valoarea CrtColumn[] pentru aranjamentul curent al evenimentului complex (liniile 29 – 31). Deoarece CrtColumn[] este intializat cu zerouri, daca gaseste primul eveniment, ajunge la 1. Acum, daca CrtColumn[] e mai mare decat 1 (insemnand ca al doilea eveniment a fost gasit, si se pregateste pentru al treilea) este necesar sa verifice daca intre evenimentele precedente (adica primul si al doilea, in acest caz) exista evenimente de negatie (acelea care sunt interzise de a aparea), numai daca NegationsCount[] pentru acel eveniment simplu specific este nonzero (liniile 40 – 59). Daca un eveniment de negatie apare, se va intrerupe cautarea – nu mai are sens, caci aranjamentul curent nu mai poate aparea. De asemenea seteaza variabila bypass la true, pentru ca partea de cod ce urmeaza, care e totusi doar o tehnica de programare pentru a face listingul sa arate mai bine – acest cod va fi executat daca nu apar negatii intre timp. Din moment ce tabloul de evenimente este bazat pe zero, evenimentul maxim care poate fi asociat este EventCount-1, si, daca CrtColumn[] pentru aranjamentul curent este egal cu EventCount, atunci toate evenimentele au fost preasociate. Evenimentul complex este aproape gata. Ceea ce urmeaza se intampla numai daca cel mai vechi eveniment inca verifica constrangerea temporala. Va verifica daca cel putin unul din evenimentele pre-asociate in aceasta trecere a fost deja asociat definitiv evenimentului complex analizat. In acest caz, va ridica true pentru steguletul any_binded, si va intrerupe. Daca steguletul nu e ridicat, atunci evenimentul complex este completat in acest aranjament, evenimentele simple sunt asociate evenimentului complex, EventsCallback() este apelata pentru a-l notifica pe utilizator, si cautarea completa este intrerupta (liniile 90-96). Altfel pre-asocierea este anulata – s-a intamplat prea tarziu. Evenimentele sunt dezasociate, negatiile si pre-asocierile sterse, cautarea este intrerupta – nu mai are sens caci e prea tarziu deja.

Apoi vine al doilea ciclu, liniile 121 – 141. Intrucat evenimentele sunt mapate de la cel mai apropiat la cel mai vehci, ele sunt raportate utilizatorului , creand evenimente complexe incomplete a caror “umbra” se manifesta in viitor oprind acelasi eveniment de la raportare, daca ar aparea din nou, dar fiind construit din alte evenimente simple. Toate pre-asocierile sunt eliminate, numai asocierile definitive ramanand valide. De notat, totusi, ca acelasi eveniment complex, conceptual, poate fi anuntat de mai mult decat o singura daca, de aranjamente diferite, daca acestea contin siruri de evenimente simple complet diferite (de exemplu 15 si 16 sau 11 si 10 , daca toate apar, insemnand acelasi eveniment, vor fi raportate amandoua aranjamentele ca fiind evenimente complexe cu acelasi ID, dar distincte), pentru ca motorul nu poate sti ca evenimentul a mai aparut si acestea inseamna acelasi lucru.

Poti intreba despre negatii, caci vezi ca negatiile sunt specifice evenimentelor, fiecare eveniment avand propriile sale evenimente de negatie intre el si evenimentul precedent. Motorul curent nu suporta negatii globale. Totusi, daca vrei ca anumite evenimente sa fie negatii globale, acestea trebuie sa fie setate intre fiecare doua evenimente simple consecutive. Primul eveniment din sir poate avea negatii asociate, dar acestea nu vor fi verificate, pentru ca nu exista un orizont temporal pentru a fi verificate. Negatiile sunt valide numai intre evenimente simple consecutive.

Acesta este un exemplu de script care foloseste motorul CEP intr-un test. Testul consta in transmiterea de evenimente abstracte catre motorul CEP. Sa-l numim 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;
}

Aceasta de exemplu genereaza urmatoarea iesire:

Te invit sa verifici logurile, pentru a vedea cum functioneaza sistemul. Incearca alte teste:
Like this:

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

Sau asa:

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

Sau asa:

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

Sau asa:

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

Acum ma vei intreba cum poti afla care sunt combinatiile de evenimente simple care sa fie legate ca evenimente complexe. Care evenimente complexe stau la baza algoritmilor de frecventa medie? Cum se pot cauta?

Ei bine, nu am absolvit CQF-ul lui Paul Wilmott. Nu-ti pot spune asta. Sunt un simplu absolvent de finante din Romania, probabil urmand sa fiu prajit in mizeria ce sta sa vina in sectorul public in care din pacate lucrez. Am dat doar o sugestie minora despre mecanica acestei cautari in articolul despre sistemele cu reglare automata. Daca ai creierii si puterea de a merge mai departe, si de crezi in valoarea de fata a lucrurilor, corectitudinea educatiei si alte chestii blah blah – incearca sa-ti faci un master in Finante Computationale – sau in Finante Cantitative – ar trebui sa fie de-ajuns. Daca nu poti sa-ti finantezi unul, incearca Finlanda. Mi se pare ca Hanken e o solutie destul de cinstita – daca ai nervii de a trece prin hartii si intrebari. Altfel, studiaza singur si implementeaza acasa – cu toate limitele decurgand de aici!

Linkuri:
CEPEngine.mqh
ceptest.mq5

Combinatorica in MQL5

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

[English version] [MQLmagazine.com in english] [Editia romaneasca]

Cu mult timp in urma am scris pe fostul meu blog despre generarea permutarilor, dar nu m-am scufundat destul de mult in explicarea algoritmului si a codului. Intr-adevar, exista situatii cand combinatorica trebuie sa fie aplicata – cand cautam arbitraje sau pentru statistici care au ca cerinta selectia activelor.

Permutari

Permutarile sunt destul de simplu de gasit si de generat, desi manualele de matematica sar peste acesti algoritmi. Daca permutarile sunt ordine specifice in care elementele unei multimi sunt aranjate, aceasta inseamna ca in timp ce aranjam elementele, posibilitatile de a aranja elementele ramase se reduc. Daca avem 4 elemente intr-o multime, dupa ce-l asezam pe primul mai ramand doar 3 locuri disponibile, si asa mai departe pana cand ultimul element se aseaza automat in singurul loc liber ramas. De aceea, compozitia numarului care da permutarea se face ca la compuneerea unui numar intr-o alta baza de numeratie, cu diferenta ca baza de numeratie se micsoreaza la fiecare pas.

De exemplu avem de gasit numarul urmatoarei permutari:

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

La inceput, baza de numeratie este 4, iar tabloul nostru este gol:

|1|2|3|4| : notatia matematica a pozitiilor
|1|4|2|3| : permutarea de descifrat

|0|0|0|0| : locuri ocupate in notatia pozitiilor, in prezent
|0|1|2|3| : locuri in tablou (de la zero)
|0|1|2|3| : tablou de numarare

Ne uitam la prima pozitie, 1, si citim primul element, “1″. Din ratiuni de computing folosim tablouri bazate pe zero.
Numarul permutarii = 1-1 = 0

|1|2|3|4| : notatia matematica a pozitiilor
|1|4|2|3| : permutarea de descifrat

|0|0|0|0| : locuri ocupate in notatia pozitiilor, in prezent
|1|0|0|0| : locuri ocupate in notatia pozitiilor dupa inserare
|0|1|2|3| : tabloul de numarare (conceptual, doar pentru numarare)
|x|0|1|2| : noul tablou de numarare pentru elementele ramase.

Acum ne uitam la al doilea element. Al doilea element este “4″. Acum, pentru ca mai avem doar 3 locuri libere, baza de numeratie este 3. Numarul permutarii = (0 x 3) = 0. La aceasta, adaugam pozitia in tabloul de numarare pentru elementul “4″, care este 2 : Numarul permutarii = 0 + 2 = 2

|1|2|3|4| : notatia matematica a pozitiilor
|1|4|2|3| : permutarea de descifrat

|1|0|0|0| : locuri ocupate in notatia pozitiilor, in prezent
|1|0|0|4| : locuri ocupate in notatia pozitiilor, dupa inserare
|x|0|1|2| : tabloul de numarare
|x|0|1|x| : noul tablou de numarare pentru elementele ramase

Acum ne uitam la al treilea element. Al treilea element este “2″. Acum cand avem 2 locuri libere, baza de numeratie este 2.
Numarul de permutare = (2 x 2) = 4. La acesta, adaugam pozitia in tabloul de numarare pentru elementul “2″, care este 0 : Numarul de permutare = 4 + 0 = 4

|1|2|3|4| : notatia matematica a pozitiilor
|1|4|2|3| : permutarea de descifrat

|1|0|0|4| : locuri ocupate in notatia pozitiilor, in prezent
|1|2|0|4| : locuri ocupate in notatia pozitiilor, dupa inserare
|x|0|1|2| : tablou de numarare
|x|x|0|x| : noul tablou de numarare pentru elementele ramase.

Calculul se opreste. Avem de inserat numai n-1 elemente. Al n-lea element este prezumat a se afla in locul ramas liber.

Numarul de permutare final = 4

Algoritmul invers, de generare a permutarilor din numerele de permutare, este urmatorul:
Incepand de la baza 2, efectuam n-1 pasi de divizune la o baza in crestere, pastrand restul.
Astfel avem
4 / 2 = [2], remainder 0
[2] / 3 = 0, remainder 2
[0] / 4 = 0, remainder 0

Apoi incepem sa construim permutarea la loc. Citim ultimul rest, pe care il gasim a fi 0. Aceasta inseamna ca primul element este intr-adevar “1″, pentru ca 0 din tabloul de numarare este 1 in tabloul pozitiilor.

|1|2|3|4| : notatia matematica a pozitiilor
|0|1|2|3| : subscripturi fizice in variabila tablou
|0|1|2|3| : tablou de numarare
|1|0|0|0| : pozitii ocupate dupa inserarea elementului curent
|x|0|1|2| : tablou de numarare dupa inserarea elementului curent
|1|0|0|0| : permutarea construita

Baza s-a micsorat la 3, pentru ca mai avem 3 locuri ramase. Citim restul urmator, in ordine inversa, si gasim ca este 2. Uitandu-ne in noul tabloul de numarare, vedem ca pozitia 2 corespunde elementului “4″ din notatia matematica.

|1|2|3|4| : notatia matematica a pozitiilor
|0|1|2|3| : subscripturi fizice in variabila tablou
|x|0|1|2| : tablou de numarare
|1|0|0|4| : pozitii ocupate dupa inserarea elementului curent
|x|0|1|x| : tablou de numarare dupa inserarea elementului curent
|1|0|0|4| : permutarea construita

Baza s-a micsorat la 2, caci mai avem 2 locuri libere. Citim restul urmator, in ordine inversa, si gasim ca este 0. Uitandu-ne in noul tablou de numarare, vedem ca pozitia 0 corespunde elementului “2″ din notatia matematica.

|1|2|3|4| : notatia matematica a pozitiilor
|0|1|2|3| : subscripturi fizice in variabila tablou
|x|0|1|x| : tablou de numarare
|1|2|0|4| : pozitii ocupate dupa inserarea elementului curent
|x|x|0|x| : tablou de numarare dupa inserarea elementului curent
|1|4|0|2| : permutarea construita

Mai avem un singur element de determinat, si acesta este “3″, pe singurul loc ramas neocupat.

|1|2|3|4| : notatia matematica a pozitiilor
|0|1|2|3| : subscripturi fizice in variabila tablou
|x|x|0|x| : tablou de numarare
|1|2|3|4| : pozitii ocupate dupa inserarea elementului curent
|x|x|x|x| : tablou de numarare dupa inserarea elementului curent
|1|4|3|2| : permutarea construita

Pentru ca ambii algoritmi sunt liniari, ei poti fi implementati direct in functii. Astfel, incepem sa scriem 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)));
    }
 
//*************************************************

Lucruri obisnuite pe care nu insistam, mergem mai departe spre Permutari:

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

De data asta am avut noroc. Doar doua functii simple de apelat. Nu va fi si cazul Combinarilor.

Combinations

Algoritmul de combunari este mult mai greu de inteles decat algoritmul de permutari. Cel mai folosit algoritm este cel care genereaza combinarile intr-o manevra recursiva.

Sa ne uitam la urmatoarea serie de combinari: C(5,3)

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

Mai intai, fiecare element are un grad de libertate diferit. De exemplu, prmul nu poate fi dincolo de n-k+1.
Alt lucru, dupa ce generezi prmul element, ceea ce ai de facut sunt C(n-1,k-1).
De exemplu, C(4,2) sunt:

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

Pentru fiecare dintre acestea, C(3,1) sunt:

1
2
3

Acum poti vedea cum se integreaza:

Cand procedura este apelata pentru a genera C(5,3) incepe prina a enumera primul element, de la 1 la 3. Astfel, are:

1,(1+x)

Apoi se autoapeleaza pentru a genera C(4,2) , si enumereaza de la 1 la 2.

1,(1+1),(2+x)

In final se autoapeleaza pentru a genera C(3,1) si completeaza:

1,2,(2+1) = 1,2,3
1,2,(2+2) = 1,2,4
1,2,(2+3) = 1,2,5

Se intoarce la ciclul urmator si continua cu urmatorul element din C(4,2) si anume 2:

1,(1+2),(1+2+x)

Apeleaza apoi C(3,1) si completeaza:

1,3,4
1,3,5

Se intoarce apoi la C(5,3) si continua sa enumereze urmatorul element, 2.

Algoritmul continua pana cand prima apelare incheie ciclul de enumerare.

Implementarea algoritmului e destul de intunecoasa. De aceasta data am optat pentru o clasa. Deoarece, daca generarea directa nu este posibila, nu e fezabil sa generezi combinatiile de fiecare data cand vrei o anumita combinatie, in cazul in care poti dori mai multe dintr-o lista. Asadar, e nevoie de o clasa, care aduce un loop interior de generare a combinatiilor in timp ce apeleaza o functie callback care sa-i dea utilizatorului combinatiile gasite, cu optiunea de terminare anticipata.

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

Asta e o nuca mai greu de spart. Functia interesanta aici, motorul in sine, este GenCombinationsRec(). Parametrul depth spune functiei la ce nivel incepe generarea combinarilor. Cand depth este epuizat, adica la sfarsitul fiecarei cozi de apelare, o noua combinare este generata in current_combination[] si contorul este incrementat. Ceea ce are userul de facut, e sa mosteneasca aceasta clasa intr-o clasa proprie si sa supraincarce CombinationsCallback(). De asemenea, variabila terminate este disponibila, iar daca e setata la true, odata ce CombinationsCallback() termina, toate apelurile GenCombinationsRec() se vor incheia inainte de vreme si programul isi va relua executia.

Arrangements

Intrucat aranjamentele sunt combinatii permutate, nu e niciun rost de a complica problema. Clasa de aceasta data e aproape o copie a clasei CombinationObject, cu diferenta ca metoda recursiva aici, GenArrangementsRec(), este ca si GenCombinationsRec(), genereaza combinari, si apoi, cand fiecare dintre ele este gata, le permuteaza si serveste fiecare aranjament (combinatie permutata) catre ArrangementsCallback(). Simplu si convenabil, dar rezultatele nu sunt chiar in maniera sortata ca la Permutari si Combinari:

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

Si acum un script demonstrativ (combtest.mq5). Scriptul va afisa aranjamente de n perechi forex luate cate k, cu un k in crestere, de la 3 la n. Perechile forex sunt extrase la inceput, interogand fiecare instrument despre modul lui de calcul si retinand numai cele care raspund SYMBOL_CALC_MODE_FOREX, cu specificatia ca simbolul poate avea doar 6 sau mai multe litere (doua perechi forex si un sufix). Perechile sunt extrase si adaugate intr-un tablou. Apoi un motor customizat de aranjamente este apelat pentru a afisa aranjamentele:

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

Cam asa arata (desi trebuie oprit cu ajutorul lui terminate – altfel va sari o parte din jurnal):

Ai putea intreba de ce am optat pentru ca permutarile sa foloseasca int in loc de uint sau long. Raspunsul e problema legata de MathMod() si MathRound(). Aceste functii nu lucreaza cu tipuri intregi. Chiar daca asteapta si intorc intregi ca si inteles ele inca lucreaza cu double ca si tip. Asa ca toate convertirile trebuie sa se bazeze pe un cast fortat al unui double, care e un real cu semn, asa cum int e un intreg cu semn. Folosirea intregilor fara semn sau chiar long care se intinde pe 8 bytes in loc de 6 ca double ar fi complicat problema. Cred ca functiile trebuie sa fie refacute de MetaQuotes, pentru a lucra numai cu timpuri intregi si pentru a se supune tipurilor intregi primite care joaca rol de operanzi, tot asa cum div si mod lucreaza in implementarile Pascal. Iar in legatura cu MathRound(), aceasta trebuie sa fie o functie reala de rotunjire care intoarce un intreg conform tipului care asteapta rezultatul, sau intr-un tip intreg generic, cand e folosita in expresii.

Linkuri:
Combinatorics.mqh
combtest.mq5