MQLmagazine.com

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

O metoda statistica pentru autoreglarea sistemelor de trading

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

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

Incep sa scriu acest articol in ideea ca ar putea deveni folositor intr-un interval de timp nu prea indepartat. M-am gandit la asta de ceva vreme. Ideea de autoreglare a aparut de ceva vreme, dar complexitatea extrema a sistemelor de retail trading au facut-o imposibil de aplicat. Totusi, sistemele HFT sunt in general simple, si reguli similare sunt aplicate pe sute de titluri, intr-o maniera parametrizata. De aceea, daca regulile ar fi simple si ar putea fi scrise gen “cand apare asta, faci asta, rezultand asta”, in loc de logica de labirint a sistemelor de retail, atunci un set de statistici optime pe datele de intrare (intinzandu-se pe un tablou de cotatii, date de orderbook s.a.m.d.) este premisa pentru operatii gen cotare, primire de executii, take profit sau stop loss in doar cativa ticksi. Asa cum s-a vazut in articolul despre Progress Apama, acesti algoritmi sunt foarte instabili, fiind o continua cautare pentru algoritmi mai noi.

Acum poti intreba, de ce am incerca autoreglarea sistemelor de trading din moment ce institutionalii nu o fac (cel putin la nivelul HFT). Chestia e ca algoritmii lor sunt atat de rapizi incat pot sa nici nu aiba timp suficient de a inregistra datele in baza de date, incat autoreglarea, care necesita analiza suplimentara, ar fi o completa pierdere de timp, aducand prea putine imbunatatriri algoritmilor comparata cu latenta suplimentara care se formeaza. Ce va veni in aceste articole are de aceea o natura experimentala si nu trebuie luata ca solutie, ci ca incercare – nu pot spune sigur daca exista vreun sens in a incerca sa gasesti, cu statistici obisnuite, parametri recurenti ai unui proces stochastic.

Asa ca, sa presupunem ca un tablou de parametri (cum ar fi volatilitati individuale, medii mobile, volume de executii) va fi inregistrat intr-o baza de date sau un tablou. Trebuie sa luam in considerare si faptul ca un semnal de trading poate exista permanent, la fiecare tick. Presupunand volumul a fi constant, acelasi semnal poate fi in doua directii : cumparare sau vanzare. Fiecare semnal poate avea doua rezultate, unul pentru cumparare, unul pentru vanzare. Putem crea totusi reguli separate pentru vanzare.

De exemplu, un semnal cuprinse de volatilitate si distanta dintre cotatia mediana si media mobila a cotatiei mediene este de : 0.03 stddev si 2 ticksi. Ca sa-l rasucim putin , introducem cotarea, si notam 0 pentru situatia fara executii. Pusa intr-un buy cu 3 ticksi take profit si 2 ticksi stop loss, la un anumit moment, face 2 ticksi profit, pusa intr-un sell, nu are executii. Deci bazei de date cu cumparari va fi adaugata inregistrarea (0.03 ; 2 ; 2), iar celei cu vanzari (0.03 ; 2 ; 0).

Si acum lucrurile devin interesante. La sfarsit, dupa ce datele sunt stranse pentru o masa de semnale care constituie “numarul mare” pentru statistici, ne uitam prin baza de date. Mai intai, la o prima privire vom grupa baza de date dupa actiune si rezultat. In acest caz, avem sase stari finale:

1. BUY: coteaza, executie, take profit (BQFT)
2. BUY: coteaza, executie, stop loss (BQFS)
3. BUY: coteaza, fara executie, anulare ordin (BQC)
4. SELL: coteaza, executie, take profit (SQFT)
5. SELL: coteaza, executie, stop loss (SQFS)
6. SELL: coteaza, fara executie, anulare ordin (SQC)

Avem deci sase cazuri. Analizand BUY cu cotatie, executie si take profit, este doar una din cele sase stari si va consta intr-o parte mare a datelor, la fel ca si celelalte stari. Scopul analizei statistice e de a avea o statistica pregatita pentru fiecare caz. De exemplu, cazul nostru ar trebui sa arate, la sfarsit, cam asa:

0.03, 2 : 45% BQFT, 35% BQSL, 20% BQC ; 30% SQFT, 30% SQSL, 40% SQC

Dupa ce masa initiala de semnale impreuna cu rezultatele este colectata, statisticile trebuie sa fie lansate pentru fiecare combinatie de parametri. Avand numere reale ca parametri, cu multe zecimale, va conduce la faptul de a avea un numar mare de cazuri, egal cu numarul de semnale de input, facand statistica imposibila. Asa ca e nevoie de agregarea datelor. De exemplu, pentru fiecare set de parametri, pot fi calculate quartilele si apoi numarul de grupuri cu formula Freedman-Diaconis (e doar un exemplu, alte metode pot fi aplicate). Aceasta va conduce la un numar diferit de grupuri pentru fiecare dintre parametri. Apoi un nou tabel va fi creat, iar fiecare caz va avea o eticheta cu numarul de grupuri. De exemplu stddev 0.03 poate fi denumita ca “Grupul 1″ pe scara stddev si cei 2 ticksi distanta pot fi “Grupul 2″ pe scala distantelor in ticksi. Numarul total de cazuri poate fi mai mic sau egal decat produsul grupurilor per fiecare criteriu. Daca ai 3 criterii de 10 grupuri fiecare, pot fi si mai mult de 1000 de cazuri. Mai mult ca sigur, cazurile din miez vor avea un numar mare de situatii inregistrate, iar celelalte de-abia vor avea cate una. Totusi, cu cat mai platykurtica este repartitia situatiilor per cazuri, cu atat mai mare nevoia pentru un “numar mai mare” de situatii. Dupa aplicarea statisticilor, statistica bazei de date va arata cam asa:

Grupul 1, Grupul 2 : 45% BQFT, 35% BQSL, 20% BQC ; 30% SQFT, 30% SQSL, 40% SQC

Ce e important e ca trebuie sa fie extrase statistici relevante. Daca asa stau lucrurile, care ar fi decizia de trading? Mergi pe o cumparare cu o sansa de profit in 45% din cazuri? Numai ca sa suporti 35% stop losses… Pentru ca pe latura de vanzari e mult mai rau, cu situatii de stop loss aproape egale cu cele de profit. In acest caz, decizia este una de cumparare, dar totusi cu rezerve. Daca profiturile nu sunt destul de relevante, nicio decizie nu trebuie sa se ia. Totusi, este necesar ca algoritmul sa aiba un modul de decizii care sa aleaga numai cazurile relevante pentru trading.. Dar cat de rapida trebuie sa fie masina, intrucat dupa ce datele initiale sunt stranse, cu fiecare nou semnal (care poate fi si un tick, intr-un algoritm gen HFT) va fi lansata o masiva recalculare a marimilor grupurilor pe intreaga baza de date, pentru a aduce statistica la zi, si in acelasi timp de a veni cu decizia de trading si executia in timp real ?

Amintiti-va articolul meu despre motorul CEP. CEP este vazut acolo ca un modul de recunoastere – lansare, dar daca CEP poate fi utilizat ca dispozitiv de inregistrare ? Daca CEP poate fi legat de motorul statistic? Cata latenta va adauga calculului? Mai putem vorbi de timp real?

Progress Apama : Cat de adanca e gaura de iepure a HFT ?

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

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

Luna aceasta, in timp ce asteptam noul Strategy Tester, m-am simtit destul de lipsit de idei. Am realizat ca ce incercam noi sa producem aici “se usuca”. Backtestul este crezul traderului, ceea ce-i da incredere in strategiile de trading pe care le incearca.

Pe la mijlocul lui martie am dat peste doua webinarii inregistrate despre Progress Apama intitulate “Construieste Repede, Executa Repede” (Build Quickly, Run Fast) si “De la concept la profit, imediat” (From Concept to Profit in No Time Flat) . Sigur, obiectul nostru de studiu nu este platforma Progress Apama. Aceasta e o platforma HFT (high frequency trading – trading de viteza inalta) institutionala, pe care n-o sa punem mana niciodata, dar este interesant totusi sa vedem modul lor de abordare a HFT, ca si unele dintre conceptele lor atat despre dezvoltarea sistemelor cat si despre executie. Nici macar marii jucatori de piata nu o folosesc, este pentru o elita foarte mica, la crème de la crème, din moment ce au doar in jur de 120 de clienti la nivel global.

Problema e ca HFT devine mainstream in tradingul institutional. Si cand institutionalii fac ceva, e bine sa-ti deschizi urechile mai larg, pentru ca ei iau intotdeauna banii si probabil au dreptate! Dupa un studiu al Tabb Group, firmele HFT din SUA sunt doar 2% din cele 20.000 de firme de trading, si fac in jur de 73% din volumul total al actiunilor tranzactionate. Se pare ca toata piata de actiuni e sub o “preluare ostila” din partea HFT, si procesul nu se va opri. Din ce in ce mai multe firme de trading isi achizitioneaza tehnologii HFT, sau, daca nu e posibil, cel putin algoritmi in genul HFT care sa ruleze pe platformele proprii, asa ca trendul nu se va opri. Este important ca mediul de retail sa ramana constient de ce se intampla acolo, pentru a nu avea o perceptie asupra pietei alterata de paradigme prea vechi care nu se mai aplica dezvoltarilor din prezent.

Se pare ca, de la inceputul pietelor, traderii s-au luptat intotdeauna pentru latenta, sa fie primii in a avea o anumita tranzactie. Primul exemplu care imi vine in minte e Nathan Rothschild, care a aflat primul ca Napoleon a fost infrant la Waterloo si a facut ca toata piata sa creada ca Napoleon a fost victorios ca sa poata cumpara totul pe nimic. Alt exemplu mai apropiat de zilele noastre e personajul din Reminiscences of a stock operator care isi pierde legatura cu piata si isi reduce latenta folosind noua tehnologie a vremii, telexul. Cu fiecare inovatie majora in comunicatii si computing, un nivel s-a adaugat, si ceea ce era cunoscut in anii dinainte ca piete de nivel II, unde traderii umani cotau si executau tranzactii, e acum domeniul masinilor de trading de frecventa inalta. La inceput, totul a fost despre secunde – asa cum e cazul acum cu userii MetaTrader – apoi a inceput sa se mearga din ce in ce mai adanc, la milisecunde, microsecunde, si chiar nanosecunde, la care se gandesc acum. Asta s-a intamplat pentru tehnologiile HFT s-au adaptat, si au modificat comportamentul pietei la fiecare nivel de timp: cand milisecundele au devenit disponibile, algoritmii ce rulau pe statii bazate pe secunde au inceput sa dea gres, iar acum, cand e vremea microsecundelor, statiile curente bazate pe milisecunde sunt in curs de upgrade, iar maine, statii bazate pe nanosecude le vor inlocui pe cele de la nivelul milisecundelor.

Sa fiu putin sarcastic: o microsecunda e 10^-6 dintr-o secunda, iar o nanosecunda e 10^-9. E un lung drum tehnologic pana la timpul Planck, care pare a fi intervalul minim de timp : 5.4 x 10^-44 s. La rata curenta, ar trebui sa ne asteptam la o reducere a latentei de 2 puteri ale lui 10 pe an, daca ceva nu se intampla ca sa schimbe curbura reducerii latentei.

Ce se intampla cu algoritmii datorita imbunatatirilor aduse in executie si expansiunii birourilor HFT ? Louis Lovas, Chief Architect pentru Progress Apama, explica “ori devin invechite, ori li se descopera mecanismul de functionare, ori spreadurile devin prea mari si nu mai sunt profitabile apoi”.

Dan Hubscher, Principal Product Marketing Manager – Capital Markets pentru Progress Apama citand dintr-o cercetare a AITE Group research, spune ca “si intr-un mediu relativ stabil, durata de viata a unui algoritm poate sa fie chiar si trei luni”. Acesta a fost motivul pentru dezvoltarea Progress Apama Studio, un mediu de dezvoltare rapida a strategiilor. Pentru ca durata de viata a unui algoritm e limitata, e logic ca daca-i reduci timpul de dezvoltare obtii profituri suplimentare ruland acel sistem pentru mai mult timp, timpul extra fiind castigat in timp ce altii se lupta sa-l replice pe platforme cu medii de dezvoltare mai proaste.

Ceea ce urmeaza e un exemplu din demo-ul lor. Strategia e un arbitraj statistic intre doua actiuni. O medie este calculata, impreuna cu Benzi Bollinger la 1.8 deviatii standard. Ecranul urmator arata strategia ruland intr-o instanta selectata (Bank of America vs Citigroup) , iar fereastra Scenario Instances arata ce face algoritmul in fiecare instanta (prima line e Caterpillar vs Chevron, a doua e Bank of America vs Citigroup). E o strategie predefinita, vine ca si template odata cu statia, nu e nimic secret si important in legatura cu ea.

Cateva observatii asupra strategiei
1. Asa cum se poate vedea, numai un singur spread a fost setat sa fie afisat – si veti vedea mai jos, in mod ciudat, au ales spreadul dintre preturile mediene. Daca strategia s-ar baza numai pe executii la piata, ar trebui monitorizate cel putin doua spreaduri, iar criteriul de iesire ar fi opusul celui de intrare; daca strategia s-ar baza pe cotare, ar fi patru spreaduri de monitorizat.
2. Cantitatile sunt predeterminate, ca si parametri, prima e 10, a doua 20. Algoritmul nu pare a le ajusta dupa ratia de hedge.
3. Nu vad niciun contor de ticksi sau perioada folosita pentru calculul Benzilor Bollinger.
4. Campurile de cantitate maxima se folosesc pentru controlul pozitiei. Da, acea pozitie detestata pe care o are si MT5 acum. Daca te uiti in fereastra Scenario Instances, in campurile Current Position, vezi ca valorile nu sunt 10 si 20, nu are numai aceste cantitati la un moment dat, ci pozitiile sunt insumate cu noi si noi ordine de 10 si 20, pana la inchidere sau la atingerea valorii maxime specificate de parametru. Asemenea cumulare a ordinelor poate aparea daca una din Benzile Bollinger se incruciseaza cu piata de mai multe ori, dar fara atingerea celeilalte bare.
5. Campul de timeout pare a avea rolul de depreciere a pozitiei, de a comanda inchiderea pozitiilor dupa 20 de secunde. Nu poate fi un timeout de executie pentru ca acum o secunda e un secol in HFT, iar sa astepti 20 sec pentru o confirmare a unui ordin nu-mi pare a fi HFT deloc. Sau am gresit ue in legatura cu HFT ? Vezi articolul nostru despre MetaTrader, Tick Data & Charting : De ce nu un MetaTrader de Nivel II ? !
6. Priveste scala timpului. Sunt 12 secunde intre timpii etichetati, si sunt intre 3 si 7 executii pe interval. Stii vreun EA care tranzactioneaza asa?

Ce e interesant in Progress Apama e cum sunt construite strategiile. Strategiile pot fi construite chiar fara cod, dar spre deosebire de mediile din alte campuri de activitate care incearca dezvoltare fara cod, Progress Apama reuseste cu un concept complex, dar simplu de folosit. Dupa cum spune Dan Hubscher, “conform AITE Group, timpul necesar dezvoltarii unui nou algoritmul, de la achizitia datelor si analiza, pana la dezvoltarea strategiei si pana in productie e de la 10 la 28 de saptamani”. Deci un mediu de dezvoltare rapida a aplicatiilor a fost o necesitate naturala, pentru ca asta este problema care loveste competitorii directi de pe piata platformelor institutionale, si pune Progress Apama intr-o pozitie mai favorabila. In sistemul lor de dezvoltare, toate variabilele care trebuie urmarite direct sau calculate, isi au originea in ‘blocuri inteligente’ intr-o diagrama de blocuri. Fiecare bloc ia datele ori din piata ori din alt bloc, si le scoate ca si input pentru un alt bloc, generand in acelasi timp variabile interne (care se pot vedea in panoul verde din dreapta).

Strategia e apoi proiectata ca si diagrama de flux, intr-un mod similar diagramelor folosite cand invatam algoritmica. Fiecare bloc contine conditii si comenzi scrise in engleza, toate conditiile, comenzile si varibilele fiind selectabile dintr-un meniu care apare la un clic pe butonul drept.

Dupa cum se vede, are un mediu de dezvoltare aratos, care raspunde rapid ideilor si complexitatii in continua expansiune a algoritmilor de trading, dar adevarata putere a statiei se dezlantuie cand ruleaza strategiile. Asta o face sa fie o platforma de top.

Exemplul cu arbitrajul statistic e destul de simplu, dupa cum urmeaza spreadul ca si conditie. Dar strategiile HFT adevarate sunt mai complicate, fiecare strategie putand urma evenimente asincrone care au loc pe active multiple:

Regula de Trading Algoritmic

CAND
  pretul MSFT se misca in afara mediei mobile cu 2%
URMATA DE (
        Cosul meu creste cu 0.5%
        SI  (
              Pretul HPQ creste cu 5%
              SAU
              Pretul MSFT scade cu 2%
             )
        )
TOATE INTR-O PERIODA
   de 2 minute, oricand

ATUNCI
    Cumpara MSFT
    Vinde HPQ

streamuri multiple de date

secventiere temporala

secvente de evenimente complexe

constrangeri in timp real

actiuni automate

Cand am avut noi vreodata o asemenea abordare? Cand a a contat vreodata restrictia temporala in care semnalele trebuiau sa vina? Of, am uitat, nici macar nu aveam backtesterul…. O observatie interesanta despre viziunea lor, este CAND. In repetate randuri, Dan Hubscher si Louis Lovas explica cum CAND nu e acelasi lucru ca DACA. Fara comentarii.

Pentru a face acest gen de conditii utilizabile de catre proiectantul strategiei, Progress Apama vine cu o chestie inteligenta numita Procesarea Evenimentelor Complexe:

Procesarea Evenimentelor Complexe:
“Daca un articol de stiri referitor la IBM e urmat de o crestere cu 5% a pretului actiunii pe orice perioada de 10 secunde si e corelata cu o crestere a indicelui de semiconductori (n.tr. simbol SOX) atunci cumpara 1000 de actiuni IBM”

Dan Hubscher defineste Procesarea Evenimentelor Complexe ca “abilitatea de a lega doua sau mai multe evenimente, chiar daca acestea apar intr-un interval de timp, si de a le determina semnificatia din acea relatie imediat, cum ar fi detectia unui semnal de trading, sau a unei oportunitati de genera alfa.”

Dar noi nici macar nu avem OnNews(), asa e?…

E clar, cuvantul “imediat” inseamna ca trebuie sa ai cea mai redusa latenta posibila. Eu cred ca CEP poate fi tradusa in MetaTrader, incepand cu implementarile OnChart() si OnTrade() din articolele mele anterioare, si transformarea acestor metode in Procesoare de Evenimente Complexe, care traduc evenimentele de tick si tranzactie in evenimente inteligibile , gen “MSFT peste Banda Bollinger de 10 secunde”, urmate de o stampila temporala, si asezate intr-o coada. Coada poate fi preluata de o alta procedura, care aplica restrictiile temporale, genereaza semnale, si le transmite modulelor decizionale. Cititi articolul nostru Anatomia unui motor CEP simplu.

Totusi, ce face Progress Apama sa fie “masina de un milion de dolari” nu e niciunul dintre aceste lucruri, pentru ca sunt simple unelte, care pot fi folosite si de statiile de retail, daca developerii ar include asemenea facilitati. Sigur, uneltele de dezvoltare rapida conteaza atunci cand e comparata cu competitorii. Ci, este abilitatea de a rula sute de instante, bazandu-se pe infrastructurile multicore, fara a piede din avantajul de latenta. Si aceasta se face de catre Corelator(ii) de Evenimente.

Progress Apama – Facilitati de Scalare

Iesire si latenta

Hiperarbore si Secventiator de Evenimente Complexe

Milioane de reguli rulate concurent prin algoritmi inteligenti

Determinism

Corelator Paralel

Utilizeaza optim structuri multicore

Mai multe instante Apama intr-o retea

Corelatorii pot fi imbinati in configuratii CEP arbitrare (conducte, ochiuri de retea, grile)

Router de evenimente

Instalare in medii multiprocesor intinse

Monitorizare si management enterprise

Configurare grafica printr-o consola de management

In Progress Apama exista si posibilitatea de a programa. Vine cu limbajul MonitorScript, un limbaj similar Java, dar mai simplu, simultan cu o implementare completa Java:

Limbaje de programare in Apama

MonitorScript : Apama EPL (Limbaj de Procesare a Evenimentelor)

Potrivire declarativa + procesare imperativa

“monitoarele” vin cu incapsularea

instalate/dezinstalate dinamic

“ascultatorii” potrivesc, ruteaza si emit evenimente

potrivesc secventele de evenimente incluzand constrangerile temporale

sunt setate/eliminate prin expresii de evenimente

“contextele” suporta procesarea paralela

Suport complet pentru Java

Masina virtuala Java incarcata in motorul CEP

interoperabila cu MonitorScript prin rutarea de evenimente

Asa cum am zis mai sus, includ aici parti din codul arbitrajului statistic, cele care cred eu ca explica cel mai bine miezul strategiei, gasite in webinar:

Aceasta este actiunea beginTrading(), care arata dulciurile din MonitorScript. Dupa cum se poate vedea,
route in acest caz, preia datele din piata. Dar ce e mai important aici, consta in declaratiile on. AceThis statement defines ascultatorii, cu o sintaxa de tipul:

1	on [all] <expresie de eveniment> <parte de actiune>

Primul on pe care il vezi verifica distrugerea instantei de catre utilizator (intr-o maniera similara lui WM_CLOSE trimis catre WindowProc() ), apoi elimina variabilele si inchide instanta. Al doilea on e mai interesant. Aici, al doilea si al treilea sunt scrise intr-o maniera relativ redundanta, pentru ca prima conditie este un and iar a doua este or. Dupa cum noteaza Louis Lovas in comentariu, sa fim siguri ca avem cel putin un tick de la fiecare inainte de a trece mai departe, ar reiesi ca evenimentul Depth() este declansat de un nou tick, dar se pare ca Depth() este declansat cand structura orderbook se schimba, adica atunci cand cel putin un volum se schimba pe Bid sau pe Ask, nu numai cand vine un nou tick (schimbare a Bid sau Ask). Depth() pare a fi declansat similar cu OnBookEvent() care nu a fost completat inca de MetaQuotes, pe care l-am explicat in alte articole unde am spus ca va declansa mult mai frecvent decat OnTick(). Lasand comparatia la o parte si continuand cu codul, vedem a doua conditie, scrisa de Louis numai ca sa arate cat de flexibila e sintaxa, si ceea ce lanseaza, actiunea processNextSpread().
Un lucru interesant e de remarcat in legatura cu ascultatorii. Uitandu-ne la ascultatori vedem o sintax destul de avansata, mult indepartata de rigiditatea sistemului bazat pe evenimente pe care MetaQuotes se chinuie sa-l faca, si care exista deja in alte statii. Mai intai, ascultatorii se aplica oricarui fel de eveniment care este legat de datele subscrise. Dincolo de asta, descrierea evenimentului apare chiar in corpul ascultatorului, si poate fi oricare. Chiar si daca vrei sa preiei un tick pe un alt instrument, trebuie sa rulezi un expert separat (daca nu cumva va fi posibil prin OnBookEvent() ), pentru ca OnTick() raspunde numai de instrumentul curent. In acelasi timp, fiecare ascultator este o conditie de eveniment – implementare de actiune, instalabil aproape in orice parte a codului, dand un grad ridicat de libertate programatorului, pe cand in sistemul bazat pe evenimente tratarea fiecarui tip de eveniment este restransa la un singur corp de cod, unde analizeaza toate evenimentele de acelasi tip, si care daca ar fi tradus in MonitorScript ar insemna ca toti ascultatorii lucrand cu acelasi tip de eveniment sa se afle intr-un singur corp de cod.

Dupa cum se poate vedea, spreadul e calculat chiar cu preturile de mijloc. Ce e mai important, e ca metoda incapsuleaza toata strategia, si se poate vedea cum trimite ordine, fara sa verifice ordinele precedente, demonstrand inca o data sistemul pozitional.

Se pare ca toata actiunea SubmitOrder() a fost scrisa cu scopul de a face update la variabilele strategiei. Probabil intregul cod ar fi putut sta in processNextSpread(). Ciudat, variabilele de pozitie sunt calculate, prin adaugare sau scadere de volum, in loc sa se foloseasca o functie pentru a pozitia pe fiecare instrument, acolo unde ar fi necesar. Ce nu e clar in cod e unde sunt aplicate constrangerile de pozitie maxima precum si timeout-ul ordinelor.

Ceea ce e esential la Progress Apama e ca poate rula milioane de reguli concurente si face uz de mediile multicore.

Aici se poate vedea o strategie ruland cu date simulate in 500 de instante pe o masina quad core:

Deci, daca Louis Lovas spune ca merge pe o masina quad core, si nu avem niciun motiv sa nu-l credem, inseamna ca Irene Aldridge a avut dreptate, si cerintele din ce in ce mai ridicate ale gamerilor au impins tehnologia pana la punctul la care calculatoare care pot rula HFT se gasesc in fiecare casa ; dar, ce broker iti va da latenta redusa pentru contul tau sarac de retail si cine iti va da o platforma care sa nu risipeasca resursele procesorului ?

Desigur, n-o sa putem niciodata sa facem asa ceva. Userii MetaTrader nici macar nu au bani suficienti pentru cerintele de marja necesare rularii portofoliilor care reconstruiesc indecsi cu greutatile specifice necesare, asa ca tradingul low latency se scoate din discutie. MetaTrader nu va avea niciodata latenta redusa. Totusi, anumite elemente de HFT, cum ar algoritmii sau procesarea evenimentelor complexe pentru cateva strategii cu o scalare redusa, care se intind pe un numar foare limitat de active, pot fi aduse in MetaTrader. Scopul acestui articol a fost de a introduce cititorii in lumea HFT a problemelor specifice ei.

Tick Data & Charting : De ce nu un MetaTrader de Nivel II ?

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

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

Ar trebui sa vezi acest articol ca pe o continuare a celui despre Progress Apama, pentru ca vine cu probleme institutionale la nivelul MetaTrader5. Daca vezi strategia de arbitraj statistic, o sa observi ca are o executie cel mult la 1-2 secunde. Deci, nu pare HFT deloc. Dar devine HFT in contextul rularii a 500 de instante – pentru ca va avea sute de executii pe secunda. Totusi, pana la 10-20 de instante, e ceva ce si MetaTrader5 poate suporta.

Aceasta strategie m-a inspirat sa ma gandesc la un indicator care deseneaza charturi la nivel de tick. Desigur, poti vedea un asemenea chart, dar in Market Watch, facand clic pe “Tick Chart” langa “Symbols”. Dar daca vrei sa vezi mai mult decat una la un moment dat? Asa ca am scris un indicator. Nu prea mi-a reusit, dar Rosh (Rashid Umarov) mi-a sarit in ajutor. Acesta este corpul indicatorului, scris dupa inserarea nivelelor:

//+------------------------------------------------------------------+
//|                                                        Ticks.mq5 |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2010, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_plots   2
//--- plot Bid
#property indicator_label1  "Bid"
#property indicator_type1   DRAW_LINE
#property indicator_color1  Blue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- plot Ask
#property indicator_label2  "Ask"
#property indicator_type2   DRAW_LINE
#property indicator_color2  Red
#property indicator_style2  STYLE_SOLID
#property indicator_width2  1
#property indicator_level0  0.00
#property indicator_level1  0.00
#property indicator_level2  0.00
#property indicator_level3  0.00
#property indicator_level4  0.00
#property indicator_level5  0.00
#property indicator_level6  0.00
#property indicator_level7  0.00
#property indicator_level8  0.00
#property indicator_level9  0.00
#property indicator_level10  0.00
#property indicator_level11  0.00
#property indicator_level12  0.00
#property indicator_level13  0.00
#property indicator_level14  0.00
#property indicator_level15  0.00
//--- input parameters
input int      number_of_ticks=1000;
input int      points_indent=10;
input int      LevelsCount=7;
//--- indicator buffers
double         BidBuffer[];
double         AskBuffer[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,BidBuffer,INDICATOR_DATA);
   SetIndexBuffer(1,AskBuffer,INDICATOR_DATA);
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0);
   PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0);
   IndicatorSetString(INDICATOR_SHORTNAME,Symbol()+" Tick Chart");
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
   static int ticks=0;
//---
   if(ticks==0)
     {
      ArrayInitialize(AskBuffer,0);
      ArrayInitialize(BidBuffer,0);
     }
   setMaxMinPrice(ticks,points_indent);
//--- CopyRates
   MqlTick last_tick;
   if(SymbolInfoTick(Symbol(),last_tick))
     {
      BidBuffer[ticks]=last_tick.bid;
      AskBuffer[ticks]=last_tick.ask;
      int shift=rates_total-1-ticks;
      ticks++;
      BidBuffer[rates_total-1]=last_tick.bid;
      AskBuffer[rates_total-1]=last_tick.ask;
      PlotIndexSetInteger(0,PLOT_SHIFT,shift);
      PlotIndexSetInteger(1,PLOT_SHIFT,shift);
      Comment("Bid =",last_tick.bid,"   Ask =",last_tick.ask);
     }
 
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+
//| set Maximum and Minimum for an indicator window based on last values
//+------------------------------------------------------------------+
void setMaxMinPrice(int last_values,int indent)
  {
   int dgs;
   double dist;
int visiblebars=(int)ChartGetInteger(0,CHART_VISIBLE_BARS);
   int depth=MathMin(last_values,visiblebars);
   int startindex=last_values-depth;
   if (startindex<0) startindex=0;
   int max_index=ArrayMaximum(AskBuffer,startindex,depth);
   max_index=max_index>=0?max_index:0;
   int min_index=ArrayMinimum(BidBuffer,startindex,depth);
   min_index=min_index>=0?min_index:0;
   double MaxPrice=AskBuffer[max_index]+indent*_Point;
   double MinPrice=BidBuffer[min_index]-indent*_Point;
   IndicatorSetDouble(INDICATOR_MAXIMUM,MaxPrice);
   IndicatorSetDouble(INDICATOR_MINIMUM,MinPrice);
   dgs=SymbolInfoInteger(Symbol(),SYMBOL_DIGITS);
   dist=NormalizeDouble( (MaxPrice-MinPrice)/(LevelsCount+1), dgs);
   for (int i=0;i<LevelsCount;i++)
      {
       IndicatorSetDouble(INDICATOR_LEVELVALUE,i,MinPrice+dist*(i+1));
      } 
  }
//+------------------------------------------------------------------+

Ca si indicator la nivel de tick, arata bine. Dar daca vrei sa mai pui ceva pe el, cum ar fi medii mobile sau benzi Bollinger, sau chiar sa monitorizezi spread-uri, ca in fereastra strategiei din Progress Apama ? Asta inseamna ca trebuie sa scrii indicatori din nou si din nou, numai ca sa-ti arate. Desigur, calculele sunt simplu de facut dintr-un expert – vor avea loc in marea majoritate in evenimentul OnTick() – dar ai nevoie de indicatori ca sa te ajute sa-ti vizualizezi strategia, chiar si daca aplicarea lor practica va fi in mai tot timpul non necesara, datorita calculului separat in expert. Dar fii constient ca nu exista istoric la nivel de tick. Asemenea indicatori deseneaza de la zero. Daca vrei sa vezi pe termen mai indelungat, chiar si cata vreme Strategy Tester nu e disponibil ca sa poti pune indicatorul pe el, trebuie sa-i dai timp sa afiseze, nefiind instant ca ceilalti indicatori.

Deci, daca ar exista istoric la nivel de tick, insemnand si PERIOD_TICK de asemenea, atunci anumite lucruri bune pentru noi vor aparea, cum ar fi:
a. Nu ar fi nevoie de indicatori speciali pentru nivelul de tick.
b. Charturile la nivel de tick apar imediat si se intind pe tot istoricul
c. Istoricul la nivel de tick va face backtesterul mai corect, pentru ca nu va avea nevoie sa inventeze ticksi ca sa acopere asemenea zone.
d. (bila neagra): Spatiu foarte mare de hard disk ocupat de istoric, cerinte mai mari de memorie.

Ce inseamna pentru MetaQuotes:
a. Schimbare in istoric si agregarea datelor, incepand de la tick pentru a face restul, nu de la M1, pastrand M1 ca referinta pentru istoricul vechi unde datele de tick nu sunt disponibile;
b. Modificari minore la functiile de acces la date (gen campuri openbid, openask, closebid, closeask la structura MqlRates etc).
c. Modificari minore la backtester;
d. MetaTrader brandat ca platforma aproape institutionala.

De ce am vrea asta? Ei bine, de ce baietii mari nu folosesc charturi la nivel de bara? La urma urmei, nu exista surprize pe charturile la nivel de tick – si o sa investigam asta alta data – asa ca n-o sa te mai temi ca o bara ca un picior de paianjen iti va atinge stop loss in mijlocul unui trend care arata bine.

Asa ca, daca ai Nivelul II disponibil, si daca il automatizezi, esti aproape de nivelul HFT. De fapt, ceea ce e blama astazi nu e intregul trading algoritmic – pentru ca nu se gandesc niciodata la userii de MetaTrader, E-Signal sau chiar NeoTicker – ci tradingul institutional , necinstit (a se citi “colocat”). La suprafata, discutia este de conflictul intre tradingul computerizat si cel uman. Dar ambele parti ale conflictului lucreaza pe Nivelul II, unde exista posibilitatea de a cota si a avea ordinul executat (adica sa cumperi la bid sau sa vinzi la ask), si sa platesti mici comisioane pentru aceste tranzactii. Chestia e ca, daca am avea Nivel II plus automatizarea MetaTrader, cu comisioane mici de brokeraj, anumite forme de HFT ar deveni aplicabile. Asta e un lucru care a ramas ascuns, faptul ca tradingul de latenta redusa nu e chiar acelasi lucru cu tradingul de frecventa inalta. Eu cred ca tradingul algoritmic de Nivel II poate fi proiectat sa fie HFT chiar daca nu beneficiaza de executia cu latenta redusa. Problema e, traderii au fost indoctrinati asa de mult cu Nivelul I, incat e foarte greu sa faci ca Nivelul II sa fie acceptat. Pentru ca Nivelul I are o mentalitate “cumperi sau vinzi acum, vezi mai tarziu daca ai avut dreptate”, pe cand Nivelul II o are in gen “vezi asta, cotezi, inchizi mai tarziu daca ai avut executie”. Acelasi “mai tarziu” are intelesuri diferite, pentru Nivelul I inseamna de la minute in sus, de regula ore, pe cand la Nivelul II inseamna secunde. Stopul tarator in Nivelul II se misca pip cu pip. Si totul este pentru a face bani in timp real. Nu in ore, nu maine, nu saptamana viitoare. Ci mai degraba, ca sa vezi equity crescand de cateva ori pe minut. Ceea ce se uita de multe ori in trading, e ca strategiile de trading nu sunt pentru roboti care pot astepta o eternitate sa-si imbunatateasca strategiile de trading. Viata se intampla in timp real. Nu suntem nemuritori si dincolo de asta, tineretea e al naibii de scurta. Acesta e si unul din factorii care imping reducerea latentei. Pe de o parte, exista nevoia de a avea ordinele executate inaintea concurentei, pe de alta parte, mai multe si mai multe profituri pe o unitate de timp din ce in ce mai mica inseamna salarii mai grase pentru management… In acest timp, chiar si cel mai rationali si mai de succes traderi pe Nivelul I nu pot trece de anumite limte ale rentabilitatii. Esential, sistemele automate de Nivel II au scopul asta, de a comprima timpul, si de a obtine rentabilitati similare Nivelului I, dar intr-un timp de o suta de ori mai mic sau chiar si mai mic. Dar aceste rentabilitati sunt relative si mici, vazute din interiorul industriei hedge fund. Pentru ca, rezultatele sistemelor sunt relative fata de lichiditatea medie utilizata. Adica, o mare parte din lichiditate ramane neutilizata, dar trebuie sa intoarca rentabilitate. Si, in timp ce diversificarea e un mod de a utiliza mai multa lichiditate, timpul e cealalta fata a monedei, pentru ca o tranzactie pe secunda e un ceva, iar o suta de tranzactii in aceeasi secunda, intinzandu-se pe intervale in microsecunde fiecare, sunt altceva. Pe de alata parte, platformele HFT costa sume nerusinate de bani, iar institutiile mai mici nu si le permit, pentru ca o mare parte din rentabilitate trebuie sa finanteze costurile platformelor si salariile quantilor cu PhD. Acum intelegi de ce un MetaTrader de Nivel II, chiar fara latenta redusa, este important ? Chiar si Irene Aldridge admite ca nu sunt prea multe companii care vand produse pentru buyside. De fapt, daca excludem Strategy Runner, X-Trader si Ninja Trader, nici nu-mi aduc aminte de altele. X-Trader are o automatizare institutionala in termeni de costuri, iar Strategy Runner e asa de criptic ca trebuie sa platesti foarte mult pentru dezvoltarea strategiilor. Niciuna dintre aceste platforme nu integreaza optiunile, iar formarea pietei in optiuni, avand executii acolo, e o cale importanta de a face economii, caci spreadurile optiunilor sunt ridicate.

La urma urmei, daca te uiti pe forumul MQL5, poti vedea ca MetaQuotes cel putin pare a fi hotarata sa faca MetaTrader 5 cea mai buna platforma de trading din lume. Daca MetaTrader5 devine Level II ready (va amintiti vechile placi de baza cu eticheta Prescott ready ?) si prin generarea unei constientizari crescute asupra importantei actiunii la nivel de tick in comunitatea de retail trading, se pot determina schimbari la nivelul brokerajelor.
Pe masura ce brokerii vor da mai mult acces la ECN-uri (de la Electronic Currency Network) cu spreaduri stranse, acestea vor cobori, si e posibil ca sistemul bazat pe spreaduri chiar sa dispara, fiind inlocuit de modelul pe baza de comision – si zic aici comisioane mici, suficient de mici cat sa-l faca pe trader sa simta ca e intr-un ECN , nu ca are doar un feed de retail care brandeaza comisionul in loc de spread. In acest fel mult strategii de la nivelele institutionale vor deveni portabile catre MetaTrader si lumea de retail – care poate chiar va deveni “institutional cu latenta mare” , sau, mai important pentru traderii de retail, HFT GRATUIT, usor de instalat care nu e bazat pe latenta. Problema e, comisioanele sunt functie de volum. Cu cat e mai mare volumul, cu atat sunt mai mici comisioanele. Totusi, cel putin traderii forex au levier mare. (Da, americanii s-ar putea ca in curand sa nu-l mai aiba). Avand levier mare, pierderile mici continua sa loveasca in equity. Cat de mult ai putea suporta pierderi din comisioane pana cand acestea devin destul de mici pentru trece pe profit din rabaturi? Sa nu uitam, economia globala e in recesiune, si brokerii, ca orice afacere normala din lumea asta, traiesc din vanzari… Ceea ce-i face mai deschisi pentru inovare si reducerea comisioanelor, de la mici la infime.

Pe de alta parte, cum ar putea fi MT sa fie utilizat ca platforma de Nivel II asa cum e acum? Sigur, OrderSend() poate fi folosit intr-o maniera Level II, dar cu un backtester care doar modeleaza ticksi, in loc de a fosi ticksi reali? Cred ca nu. Datele la nivel de tick sunt absolut necesare pentru ca statia sa fie brandata ca una de Nivel II.
Totusi, mai sunt lucruri de facut pana acolo, caci MetaQuotes mai are si alte teme de facut : Strategy Tester, o sintaxa mai buna pentru OnTrade(), fereastra Depth of Market si mai ales OnBookEvent(). Cand toate acestea vor fi completate, MT5 va fi atat de departe incat vei uita de dulciurile MT4, sunt sigur de asta…

Daca traderii din comunitatea de retail nu cer totusi mai mult, nimic nu se va obtine, caci ei tin mult la Level II…

Anatomia unui motor CEP simplu

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

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

Daca n-ar fi acea abreviere CEP probabil ati intreba cum ceva inerent complex ar putea deveni simplu. Chestia e ca totul incepe mai intai a fi simplu inainte de a evolua in ceva complicat.

Chiar si daca mi-ati citit articolul despre Progress Apama, va reamintesc definitia data CEP de Dan Hubscher : “abilitatea de a lega doua sau mai multe evenimente, chiar daca acestea apar intr-un interval de timp, si de a le determina semnificatia din acea relatie imediat, cum ar fi detectia unui semnal de trading, sau a unei oportunitati de genera alfa.”

Deci, dat fiind ca trebuie sa se formeze conexiuni intre evenimente, avand o constrangere temporala, trebuie sa existe o coada de evenimente, care stocheaza evenimente individuale pe masura ce acestea sunt receptionate. Desigur, stocarea nu are loc la infinit intr-o coada in continua crestere; marimea cozii trebuie sa fie dinamica, dar lungimea ei in timp trebuie sa nu depaseasca un interval de timp predeterminat, sa zicem 5 minute. De aceea un motor CEP, care este in principal pentru HFT si trading de Nivel II, nu trebuie sa fie amestecat cu evenimente de Nivel I, deoarece acestea se intind pe un interval de timp mult mai larg, ceea ce ar face nu numai ca stiva de evenimente sa creasca pana la o marime necontrolabila, ci ar si reduce viteza motorului.

Intervalul de timp acoperit este prima limitare a motorului.

A doua, este legatura dintre evenimentele simple. Evenimentele simple nu sunt complet independente, asa cum ar reiesi din webinarul Progress Apama. De exemplu, ai putea considera o intersectie a unei Benzi Bollinger superioare ca si eveniment, dar si intersectia Benzii Bollinger inferioare. Aceste evenimente sunt complet opuse. Daca s-ar intampla amandoua, cand al doilea are loc, primul ar trebui eliminat din coada de evenimente, dupa cum se vede in schema de mai jos, evenimentul 4 este sters. Se poate opta pentru doua cai : o varianta in care evenimentele opuse sunt cautate pe o perioada in coada de evenimente – perioada dificil de estimat – sau o alta in care inainte de validarea unui eveniment complex sunt cautate evenimente opuse aflate dupa evenimentele simple care constituie evenimentul complex.

In al treilea rand, este evitarea redundantei. Implementarile proaste pot cauza redundanta, adica acelasi eveniment sa fie raportat in continuu. De exemplu, “MSFT este sub media mobila de 5 minute”. O paranteza aici – nu ma refer la chartul de 5 minute, ci la media mobila a ticksilor care au aparut in ultimele 5 minute, de aceea am zis ca MetaTrader ar trebui sa aibe istoric la nivel de tick si perioada tick activata. Cand aceasta se intampla, e un eveniment. Dar in secunda urmatoare, la tickul urmator, va fi raportata din nou, iar motorul trebuie sa o respinga, pentru ca este deja in coada de evenimente, asa cum e cazul cu evenimentul colorat in portocaliu din schema, care nici nu ia un numar, pentru ca este respins de la inceput. Asemenea situatii ar trebui evitate din start – motorul nu ar trebui sa piarda timp cu verificarea redundantei, altfel ar trebui sa filtreze aceste evenimente, dar e mai bine ca fluxul de evenimente sa fie curatat dinainte.

Aceasta e schema de functionare a motorului. Evenimentele de tick, sau evenimente mai complexe provin din evenimentul OnChart() care este declansat de mai multi EA Tick Event, asa cum am descris in articolul Evenimente de tick in MQL5 : complicate deocamdata, dar functionale .

Prima coloana este numarul evenimentului din coada, de la cel mai recent la cel mai vechi. Fiecare eveniment simplu, care este legat la date, are un numar alocat. Acelasi eveniment, cand are loc pe un instrument diferit, are alocat un alt numar, asa ca aceeasi secventa de evenimente care formeaza un eveniment complex va fi construit din aceleasi evenimente simple dar cu alti identificatori. Motorul trebuie sa stie ce evenimente sunt opuse, de exemplu 1 si 3, de asemenea caror evenimente le este permis sa apara de mai multe ori in lant, pentru ca unora le va fi permis (de exemplu evenimentele de executie (cele care incep cu E in schema)). Tuturor celorlalte evenimente li se interzice sa apara de mai multe ori – dar toturi nu de catre motorul propriu-zis, care anima coada de evenimente – ci chiar din faza de preprocesare.

In acelasi timp, motorul CEP trebuie sa recunoasca fiecare eveniment complex cunoscand toate aranjamentele de evenimente simple.
De exemplu, daca un eveniment complex pentru Microsoft (MSFT) consta in “10 urmat de (11 sau (12 si 13))” in 3 minute, atunci motorul va cauta , in 3 minute : 10, 11 ; 10, 12, 13 ; 10, 13, 12 insemnand toate caile alternative. Daca acelasi eveniment ar fi mapat pentru SP500 (^GSPC) , dat fiind ca toate subevenimentele au numere diferite, conditia va arata gen “5 urmat de (15 sau (16 si 17))”, avand aranjamentele ; 5, 15 ; 5, 16, 17 ; 5, 17, 16. Asemenea aranjamente pot fi date direct motorului, scrise direct in interior, sau generate cu un algoritm, transformand expresia binara, cu diferenta notabila ca “URMAT DE” e un “SI” necomutativ.. Pentru ca regulile sunt construite ca serii de evenimente ce apar intr-o anumita ordine, negatia nu poate exista la fel ca intr-o expresie binara. Poate fi implementata doar ca si interdictie de aparitie a anumitor evenimente pe parcursul restrictiei temporale sau in anumite secvente , drept simple evenimente interzise intre evenimentele cerute.

Se poate vedea ca am inclus in schema doua coloane de asociere. Adica, un eveniment simplu poate fi asociat la mai mult decat un eveniment complex, pentru ca altfel anumite reguli nu s-ar declansa niciodata. Evenimentele complexe trebuie sa aiba un set diferit de ID-uri la evenimente, pentru a nu se intersecta cu cele simple. Motorul va trimite evenimentele complexe spre a fi procesate de utilizator in EventsCallback(), dar in acelasi timp, userul le poate trimite printr-o conducta la un alt motor CEP.

Algoritmul de potrivire incepe cu constructia evenimentelor simple per fiecare eveniment complex. Matricea evenimentelor simple va contine pe fiecare linie cate un aranjament. Pentru ca verificarea este facuta invers, de la evenimentele recente catre evenimentele mai vechi, aranjamentele trebuie sa fie scrise invers in matrice. Fiecare eveniment complex va necesita o trecere prin coada de evenimente numai cata vreme se intinde constrangerea temporala, intr-o maniera verticala: prima trecere va verifica evenimentele de pe prima coloana, si evenimentele simple gasite in acest fel vor fi pre-asociate. Urmatoarea trecere va fi pe a doua coloana numai pentru aranjamentele care au avut o pre-asociere pe prima. Cand nu mai au loc pre-asocieri noi, cautarea este anulata pentru evenimentul complex in cauza. Totusi, pentru a minimiza timpul necesar, fiecare trecere va privi toate evenimentele pana are loc inceperea urmatoarei treceri. Cand cautarile sunt anulate pentru toate evenimentele, algoritmul se termina.
Cand un aranajament are toate evenimentele simple pre-asociate, e timpul pentru verificarea negatiilor. Mai intai, se verifica toata perioada pentru negatiile globale – evenimentele interzise pe toata perioada evenimentului complex, apoi pentru evenimentele interzise intre evenimentele pre-asociate, si in final verificarea de timp pentru a ne asigura ca ele inca respecta constrangerea temporala, evenimentele simple sunt asociate evenimentului complex, exceptie atunci cand in tabelul de asocieri al evenimentului simplu nu se gaseste deja aceasta asociere – pentru a evita re-asocierea lui la acelasi eveniment complex.
Evenimentul complex rezultat este pus intr-o coada si transmis la EventsCallback(). Trimiterea evenimentelor la EventsCallback() trebuie sa aiba loc dupa terminarea algoritmului altfel ar putea aparea apelari recursive ale motorului care nu isi vor inceta executia.Pentru evenimentele simple care sunt asociate, pozitia in tabelul de asocieri va fi completata cu evenimentul complex, si pozitia va incrementata cu o unitate.

Aici e un exemplu cu doua evenimente complexe is stagii difererite de pre-asociere:

Pentru evenimentul de MSFT, motorul gaseste evenimentul 12 la prima trecere, si il pre-asociaza pe al treilea aranjament. La a doua trecere, gaseste evenimentul 13, si il pre-asociaza pe al doilea aranjament. Mai gaseste si 12 inca o data, dar nu il pre-asociaza pe al doilea aranjament pentru ca a aparut inainte de 13. Daca la urmatoarea trecere gaseste evenimentul mai vechi, 10, al treilea aranjament este complet, si, in lipsa negatiilor, daca restrictia temporala inca e aplicabila, in conditiile in care evenimentul complex 1 nu a fost asociat inca, atunci evenimentele simple de pe al treilea aranjament sunt asociate evenimentului complex 1, contorul de asocieri incrementat, evenimentul pus in coada de asocieri. Pentru evenimentul de ^GSPC (evenimentul complex 2), motorul a completat deja primul aranjament. Evenimentul 5 nu apare verificat pentru al doilea si al treilea aranjament intrucat evenimentele de pe coloanele precedente nu au fost verificate.

Cat despre evenimentele de executie, acestea sunt trimise de EnumCallbacks(), eveniment al clasei DealHandler din articolul a title=”Distingirea executiilor cvasisimultane – clasa de raportare a ultimelor tranzactii” href=”http://mqlmagazine.com/ro/programarea-in-mql/distingirea-executiilor-cvasisimultane-clasa-de-raportare-a-ultimelor-tranzactii/” target=”_top”>Distingirea executiilor cvasisimultane – clasa de raportare a ultimelor tranzactii. Evenimentele simple de executie pot fi mapate in evenimente mai complex de executie deoarece tranzactiile au numere magice si comentarii, si daca ar fi sa cumperi de doua ori aceleasi 1000 de actiuni, vei stie fiecare din ce eveniment complex face parte. De aceea asemenea evenimente pot fi tratate ori separat ori in combinatie cu evenimentele de piata.

Vom veni cu un exemplu de cod intr-un articol viitor.

Iadul DLL, editia MQL5 : UNICODE vs ANSI

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

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

Cu multi multi ani in urma, cand eram copii, la inceputul anilor ‘90, doua limbaje se bateau in lumea developerilor. Pascal, cu o sintaxa pamanteasca, usor de inteles, potrivita unui limbaj de nivel inalt, si C++, cu o sintaxa mai criptica, dar mai rapida in folosire, potrivita nivelului sau mediu. C++ a castigat batalia, si tot ce s-a facut in Windows a inceput sa fie compilat in C++ si a inceput sa-i poarte semnele: siruri terminate cu null si ce era cunoscut atunci ca si conventia standard de apelare.

Sirurile terminate cu null erau siruri normale, cunoscute ca si siruri ANSI, dar la vremea aceea nu exista UNICODE. Fiecare caracter avea un singur byte iar sirurile aveau o lungime dinamica, intrucat erau presupuse a se termina cu null (un byte zero).
De aceea aplicatiile primeau un pointer care sa indice de unde sa citeasca aceste siruri, si stiau si unde acestea se terminau, cautand un byte zero. Cat despre conventia standard de apelare a procedurilor, compilatorul C++ impingea parametrii pe stiva incepand de la ultimul si terminand cu primul.

Sir terminat cu null (ANSI)

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

Pascal era inversul absolut al C++ in aceste privinte. Sirurile erau si ele tot ANSI, numai un byte per caracter, dar sirurile aveau o lungime fixata de 255 de bytes, sau definita de compilator. Aveau un byte exrtra in fata, specificand lungimea logica a sirului (cati bytes erau efectiv folositi). Cat despre conventia de apelare, aceasta era perfect invers, pentru ca in conventia de apelare pascal, parametrii erau impinsi pe stiva de la primul spre ultimul.

Sir Pascal Standard(ANSI)

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

De aceea sirurile Pascal puteau fi trimise cu totul functiilor, fara nevoia de a se trimite prin referinta, caci acesta este unicul mod prin care trimiterea sirurilor este posibila in C++.

Intrucat C++ a castigat batalia, compilatorul Pascal a trebuit sa se adapteze, si conventia de apelare a fost o sarcina usoara. Cat despre siruri, problema s-a complicat, iar programatorii au trebuit sa se chinuie cu PCHAR, un nume dat tablourilor fixe de cate un byte pe element, care trebuia sa tina siruri C++ terminate cu null care erau trimise prin referinta.

Ca si cum nu era de-ajuns, a aparut standardul UNICODE.

UNICODE este un standard complicat, si nici eu nu-l cunosc in intregime. Diferenta dintre ANSI si UNICODE e aceea ca in UNICODE caracterele sunt mai largi, se intind pe doi bytes fiecare, dar sunt si siruri cu caracterele codate pe 4 bytes. La inceput, sirurile UNICODE pareau ceva nou si ciudat. De aceea, erau numite siruri largi (wide strings). Functiile Windows API care lucrau cu sirurile largi aveau numele terminat in W ; pointerii la siruri ANSI terminate cu null se numeau char* , iar pointerii la siruri UNICODE au trebuit sa fie numite wchar_t*. Cum UNICODE a devenit standard general in timp, acum sirurile UNICODE sunt numite simplu siruri terminate cu null.

Siruri terminate cu null (UNICODE)

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

MQL5, ca majoritatea mediilor de programare din prezent, este UNICODE. Chiar si sirurile simple pe care le folosesti in mod regulat sunt UNICODE. Arata ca si cum ar fi ANSI, dar reprezentarea interna e UNICODE. Aceasta din cauza ca ANSI poate fi impachetat in UNICODE, prin umplerea bytes complementari cu 0.

ANSI impachetat in UNICODE (siruri normale MQL5)

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

Deci, intr-un sir ANSI impachetat in UNCODE, fiecare byte par este 0.
Dar daca ai un DLL C++ mai vechi, care foloseste siruri ANSI terminate cu null.
Aceasta inseamna ca se asteapta si intoarce siruri ANSI terminate cu null.

Deci, daca trimiti un sir “ABC” catre un asemenea DLL, vei avea mapat in bytes : 65, 0, 66, 0, 67, 0.
DLL-ul va vedea primul 0 ca si null-ul care termina sirul si va intelege doar “A” din tot sirul.

Daca e sa primesti “ABC” din acest tip de DLL, vei primi in bytes : 65, 66, 67, 0.
MQL5, fiind UNICODE, va intelege primul caracter ca 65 si 66 (ceva ce pare in chineza) si al doilea caracter ca 67 si 0, mapandu-l in “C”. Apoi va continua sa citeasca, daca nu e nici o eroare access violation pana cand gaseste 0 si 0, care formeaza null-ul, rezultand intr-o pasareasca de neinteles. Eroarrea access violation ar putea sa fie ocolita pentru ca MT5 ar putea aloca suficient spatiu pentru primirea sir.

Din pacate, MQL5 nu are un tip ansistring care sa se ocupe de conversie automat. Totusi, pe partea buna a problemei, cel putin in ambele cazuri sirurile sunt trimise prin referinta, deci e doar o problema de semnificatie decat una de conflict in trimiterea prin valoare sau referinta.

Aceasta inseamna ca trebuie sa trimiti siruri UNICODE care trebuie sa fie decodate corect ca ANSI, si sa primesti siruri ANSI pe care trebuie sa le convertesti la UNICODE pentru a le folosi.

Cand primesti un sir ANSI intr-o forma UNICODE, incepi citirea caracterelor UNICODE, printr-un typecast al fiecarui caracter intr-un unsigned short, apoi imparti acesta in doua ANSI (prin modulo 256), adaugand apoi la UNICODE-ul rezultant mai intai restul (ca si cod ANSI) , si apoi catul (ca si cod ANSI). Asa ca fiecare 2 bytes din ANSI original se mapeaza in 4 bytes (2 caractere UNICODE).

Cand vrei sa impachetezi un UNICODE codat ca ANSI, ca un sir MQL5, ca si ANSI, trebuie sa citesti fiecare doua caractere UNICODE la rand, si fortezi typecast-ul lor in unsigned char, de marimea caracterelor ANSI. Apoi impachetezi noul caracter UNICODE cu primul citit ca rest si al doilea ca si cat intr-un unsigned short mai mare, care se va adauga ca si cod al noului caracter la noul sir rezultant UNICODE.

Ceea ce urmeaza este codul celor doua functii de conversie, scrise ca o biblioteca. Fii atent cand faci acest fisier, sa fie in folderul include, si sa-l salvezi ca stringlib.mqh.

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

Cand folosesti biblioteca scrii simplu:

#include

ca in exemplul urmator:

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