MQLmagazine.com » Programarea in MQL

Linii directoare pentru scrierea expertilor de portofoliu in MQL5

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

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

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

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

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

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

De exemlu, aceasta:

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

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

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

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

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

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

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

Si acum OnTick():

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

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

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

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

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

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

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

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

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

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

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

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

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

MQL5 : Un expert demonstrativ de portofoliu folosind medii mobile

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

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

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

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

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

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

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

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

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

Aceasta este procedura MakeIndicatorHandlers() adaptata nevoilor acestui expert.

Acum urmeaza UnitsToLots(), GetPositionType(), PositionSetSLTP() si ManagePosition() care sunt cele prezentate in Linii directoare pentru scrierea expertilor de portofoliu in MQL5.

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

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

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

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

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

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

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

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

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

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

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

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

equity = sistem de trading(instrument)

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

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

Link:
PortfolioMA.mq5

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

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

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

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

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

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

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

Astfel, incepem sa scriem un astfel de sistem, pe care-l vom numi TradeVirtualization.mqh .

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

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

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

Clasa contine un tablou de VirtualSymbolsData si numarul sau de elemente, si un tablou cu VirtualEquityData. Alti parametri cheie sunt VirtualLastEquityPos si VirtualEquityBarSpan (timpul pe care se intinde o bara, in secunde). VirtualLastAccountEquity este doar un proxy pentru ultima valoare inregistrata a equity.

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

VirtualGetPositionType() si VirtualGetPositionSize() sunt pur informationale. Marimea pozitiei e intotdeauna pozitiva, tot asa cum PositionInfoDouble() intoarce valorile pentru cererile POSITION_VOLUME. Celelalte doua functii fac exact ce spune numele lor ca face – seteaza stop loss si take profit.

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

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

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

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

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

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

Acum ca am realizat clasa, e timpul sa virtualizam expertul pe medii mobile din articolul
MQL5 : Un expert demonstrativ de portofoliu folosind medii mobile, intr-un fisier nou, VirtualPortfolioMA.mq5 .

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

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

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

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

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

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

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

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

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

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

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

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

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

Acesta este OnInit(). Pregateste simbolurile la fel ca fostul OnInit() apoi copiaza simbolurile in contul virtual. Seteaza contul virtual si se asigura ca RealTrading e setat ca “FORBIDDEN”.

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

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

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

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

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

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

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

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

Linkuri:
TradeVirtualization.mqh
VirtualPortfolioMA.mq5

MQL5 : Implementarea unui motor CEP simplu

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

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

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

Acum inapoi la motorul CEP.

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

Urmatorul fisier va fi denumit CEPEngine.mqh :

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

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

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

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

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

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

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

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

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

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

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

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

Aceasta functie a fost facuta numai din ratiuni de comentare. Functia descrie un eveniment complex intr-o forma sir. Poti scoate rezultatul pe ecran cu Comment().

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

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

Acum lucrurile mici:

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

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

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

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

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

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

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

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

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

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

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

Acesta este un exemplu de script care foloseste motorul CEP intr-un test. Testul consta in transmiterea de evenimente abstracte catre motorul CEP. Sa-l numim ceptest.mq5 .

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

Aceasta de exemplu genereaza urmatoarea iesire:

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

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

Sau asa:

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

Sau asa:

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

Sau asa:

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

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

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

Linkuri:
CEPEngine.mqh
ceptest.mq5

Combinatorica in MQL5

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

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

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

Permutari

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

De exemplu avem de gasit numarul urmatoarei permutari:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Numarul de permutare final = 4

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

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

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

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

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

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

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

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

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

Pentru ca ambii algoritmi sunt liniari, ei poti fi implementati direct in functii. Astfel, incepem sa scriem Combinatorics.mqh.

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

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

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

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

Combinations

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

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

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

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

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

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

1
2
3

Acum poti vedea cum se integreaza:

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

1,(1+x)

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

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

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

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

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

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

Apeleaza apoi C(3,1) si completeaza:

1,3,4
1,3,5

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

Algoritmul continua pana cand prima apelare incheie ciclul de enumerare.

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

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

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

Arrangements

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

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

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

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

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

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

Linkuri:
Combinatorics.mqh
combtest.mq5

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

MQL5 : Conectarea la MySQL

Bogdan Baltatu, MQLmagazine editor — Wed, 31 Mar 2010 19:36:04 +0000

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

Acest articol este dedicat trimiterii de date din MQL5 catre o baza de date MySQL. Articolul este totodata o exemplificare a functiilor de conversie UNICODE/ANSI prezentate in articolul Iadul DLL, editia MQL5 : UNICODE vs ANSI.
Principalele avantaje ale colectarii datelor in baze de date MySQL ar fi: interogarea datelor, detinerea unor cantitati mari de date intr-un spatiu mai mic. De exemplu tranzactiile stocate intr-o baza de date ocupa probabil sub 10% decat intr-un fisier HTML.
Totusi, dezavantajul principal e ca un asemenea export se face pentru a analiza datele pe o alta platforma sau chiar pe platforme scrise manual, care necesita timp mare de dezvoltare si sunt expuse erorilor ascunse – fie in conceptie, fie in programare.

In primul rand trebuie sa aveti instalat serverul MySQL si un conector. Pentru functionarea codului de mai jos trebuie permis din platforma importul de dll-uri si sa puneti biblioteca libmysql.dll in folderul ‘libraries’. Am avut o problema cu un libmysql.dll pe 64 de biti. Probleme de dependente, probabil si de import (in mod normal o aplicatie pe 32 de biti nu poate importa un dll pe 64 de biti). Ca sa scapati de problemele aduse de biblioteca pe 64 biti va sfatuim sa folositi o biblioteca pentru sisteme pe baza de 32 biti.

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

Intre liniile 9 si 17 declaram functiile pe care le importam din libmysql.dll . Fiind un exemplu am importat doar 6 functii. Pentru aprofundarea functiilor folositi documentatia mysql.

Lucrul cu fisiere. Partea a IV-a

Bogdan Baltatu, MQLmagazine editor — Wed, 31 Mar 2010 19:35:48 +0000

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

Acesta este ultimul articol din seria ‘Lucrul cu fisiere’ si el va trata exclusiv functiile de citire din din fisiere. Functiile care se ocupa cu citirea din fisiere sunt :

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

FileReadArray()

Functia citeste dintr-un fisier BIN tablouri de orice tip cu exceptia string. Prototipul functiei este:

uint  FileReadArray(
 int  file_handle                            // Referinta fisierului
 void  array[],                              // Tabloul in care citim
 int   start_item=0,                       // Pozitia de la care se incepe citirea
 int   items_count=WHOLE_ARRAY    // Numarul de elemente pe care vrem sa il citim
);

Parametrii functiei sunt : referinta fisierului, tabloul in care citim, pozitia de unde incep citirea si numarul de elemente care vreau sa fie citit. Rezultatul functiei este numarul de elemente citite.

Exemplu de cod:

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

Am preferat sa scriu in fisierul bin folosindu-ma de FileWriteDouble() (liniile 3 si 4) cand puteam folosi FileWriteArray() , deoarece am vrut ca tu , cititorule sa poti sa te joci cu codul si sa poti sa tragi concluziile pe care ti le voi expune.

Pe linia 5 am apelat functia FileSeek() deoarece daca faceam imediat citirea cursorul era la sfarsitul fisierului si functia nu ar mai fi citit nici un element nemaiavand ce sa mai citeasca , asadar inainte de a folosi functia FileReadArray() asigurati-va ca pozitia cursorului este in locul dorit.

Tipul tabloului trebuie sa coincida cu tipul elementelor pe care dorim sa le citim. De exemplu daca am scris in fisier cu FileWriteDouble() , tabloul in care in ajung datele citite cu FileReadArray() trebuie sa fie de tip double. Daca nu este, datele vor fi alterate in functie de tipul matricei b ; in cazul nostru functia citeste seturi de cate 8 bytes , deoarece un numar double se scrie pe 8 bytes.

Scrieti un element cu FileWriteDouble() si unul cu FileWriteInteger() si faceti citirea intr-un tablou de tip double sa vedeti ce se intampla. Dupa ce o sa faceti asta o sa ajungeti la concluzia ca este mai bine intr-un fisier sa folositi un singur fel de functie pentru scriere si tabloul sau structura in care faceti citirea sa fie de acelasi tip cu elementele scrise.

Mare atentie la pozitia cursorului!!
Va readuc aminte ca intr-un tablou primul element se gaseste pe pozitia 0 , deci in cazul nostru primul element o sa fie b[0] si al doilea b[1].

FileReadBool()

Prototipul functiei este:

1
2
3

bool  FileReadBool(
   int  file_handle    // Referinta fisierului
   );

Functia citeste dintr-un fisier CSV un string si il converteste in boolean; false daca citeste 0, true pentru orice altceva.

FileReadDatetime()

Functia citeste dintr-un fisier CSV un string in unul din formatele: “YYYY.MM.DD HH:MI:SS”, “YYYY.MM.DD” sau “HH:MI:SS” si le converteste intr-o valoare de tip datetime. Prototipul functiei este:

datetime  FileReadDatetime(
 int  file_handle    // Referinta fisierului
);
 
Functia are un singur parametru si anume referinta fisierului data de functia FileOpen().
 
Exemplu de cod:
 
<pre lang="mql5">int fh=FileOpen("test.csv",FILE_CSV|FILE_READ|FILE_WRITE);
FileWrite(fh,"asd 12:54 06:00");
FileSeek(fh,0,SEEK_SET);
datetime dt=FileReadDatetime(fh);
FileClose(fh);

Observati pe linia 2 ca am scris in acelasi string doua substringuri care pot fi interpretate si convertite ca data (“12:54″ si “06:00″).Functia citeste intotdeaua primul string care poate fi convertit in data de la pozitia curenta a cursorului si il converteste intr-o variabila de tip data.

Daca data noastra este de forma HH:MM atunci dt va lua valoarea : “YYYY.MM.DD 12:54″ , unde YYYY.MM.DD este data curenta.

FileReadDouble()

Functia citeste un numar de tip double dintr-un fisier BIN de la pozitia curenta a cursorului. Prototipul functiei este:

1
2
3

double  FileReadDouble(
 int  file_handle    // Referinta fisierului
);

Functia are un singur parametru si anume referinta fisierului intoarsa de FileOpen() si rezultatul functiei este un numar de tip Double.

Exemplu de cod:

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

Am scris doua valori de tip double in fisier.Daca ne ‘jucam’ cu al doilea parametru al functiei FileSeek() o sa observam ca numarul difera de cel introdus deoarece functia citeste 8 bytes de la pozitia cursorului si numarul intors de functia FileReadDouble() va fi diferit de ce scris.

FileReadFloat()

Functia citeste un numar float dintr-un fisier BIN. Prototipul functiei este:

1
2
3

float  FileReadFloat(
 int  file_handle    // Referinta fisierului
);

Functia are un singur parametru si anume referinta fisierului data de functia FileOpen().

Exemplu de cod:

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

Aceleasi precizari ca la functiile de mai sus: atentie la pozitia cursorului!!

FileReadInteger()

Functia citeste un integer , short sau char de la pozitia curenta a pointerului in functie la lungimea in bytes specificata. Prototipul functiei este:

int  FileReadInteger(
 int  file_handle         // Referinta fisierului
 int  size=INT_VALUE      // Marimea unui intreg in bytes
);

Parametrii functiei sunt referinta fisierului intoarsa de FileOpen() si numarul de bytes care pe care o sa il citim de la pozitia curenta a cursorului. (1 pentru char , 2 pentru short , 4 pentru int)

Exemplu de cod:

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

Chiar daca ma repet mai adaug o data : atentie la pozitia cursorului si atentie la numarul de bytes pe care il citesti!

FileReadLong()

Functia citeste un intreg de tip long (8 bytes) de la pozitia curenta a unui fisier deschis ca BIN. Prototipul functiei este:

1
2
3

long  FileReadLong(
 int  file_handle    // Referinta fisierului
);

Parametrul functiei este referinta fisierului intors de functia FileOpen().

Exemplu de cod:

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

FileReadNumber()

Functia citeste dintr-un CSV un string de la pozitia curenta pana cand se intalneste separatorul si converteste string-ul intr-un double. Prototipul functiei este:

1
2
3

double  FileReadNumber(
 int  file_handle    // Referinta fisierului.
);

Functia are un singur parametru si anume referinta fisierului intoarsa de functia FileOpen().

Exemplu de cod:

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

Daca pe linia 2 scriam in loc de 1.2 scria “A” atunci functia FileReadNumber ar fi intors 0.

FileReadString()

Functia citeste dintr-un string de la pozitia curenta. Prototipul functiei este :

string  FileReadString(
 int  file_handle      // Referinta fisierului
 int  size=-1          // Lungimea stringului
);

Functia are ca parametri : file_handle , care este referinta fisierului intoarsa de FileOpen si size care este numarul de caractere pe care dorim sa il citim.

Exemplu de cod:

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

Daca deschidem fisierul ca text , al doilea parametru nu este necesar , functia FileReadString() va citi pana va intalni sfarsitul de linie (‘\r\n’). Nici in cazul fisierelor deschise ca CSV al doilea parametru nu este necesar , functia citeste intalneste separatorul.

FileReadStruct()

Functia citeste continutul intr-o structura dintr-un fisier BIN , incepand cu pozitia curenta a pointerului. Prototipul functiei este:

uint  FileReadStruct(
 int                file_handle      // Referinta fisierului
 any_simple_struct  str_object,      // Structura in care fac citirea
 int                size=-1          // Marimea structurii in bytes
);

Exemplu de cod:

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

As vrea sa precizez ca de la versiunea 252 a MetaEditor in FileWriteStruct() si FileReadStruct() lucreaza strict cu structuri, iar inainte lucrau si cu tablouri. In versiunile mai vechi mergea sa scriem de exemplu “FileWriteStruct(fh,a,so)” dar acum linia se intoarce cu eroare (“a – invalid access array”).

Accesarea datelor de piata in MQL5

Bogdan Baltatu, MQLmagazine editor — Sun, 28 Feb 2010 20:29:42 +0000

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

In acest articol va voi prezenta functiile de accesare a datelor despre piata in MQL5 , dar voi compara cu functia care facea acest lucru in MQL4.

In MQL4 exista o functie unica cu care se aflau toate informatiile si anume MarketInfo(). In MQL5 functia MarketInfo() a disparut , acesteia luandu-i locul functiile SymbolInfoDouble() , SymbolInfoInteger() , SymbolInfoString() ,SymbolInfoTick(). Numele fiecarei functii este format din 3 cuvinte: primele 2 sunt ‘SymbolInfo’ , si ultimul cuvant care arata ce returneaza functia respectiv ‘Double’ , ‘Integer’ , ‘String’.

SymbolInfoDouble()

Functia are 2 prototipuri si anume :

double  SymbolInfoDouble(
   string  name,        // simbol
   int     prop_id      // identificator de proprietate
);

Al doilea prototip de functie este:

bool  SymbolInfoDouble(
   string   name,       // simbol
   int      prop_id,    // identificator de proprietate
   double &double_var  // variabila rezultat
);

Functia returneaza true daca se executa cu succes (daca plaseaza valoarea intoarsa intr-o variabila trimisa ca parametru).

Identificator	Descriere	Echivalent in MQL4
SYMBOL_BID	Bid – Cea mai buna oferta de cumparare (nivel II) sau pretul de vanzare (nivel I)	MODE_BID
SYMBOL_BIDHIGH	Bid-ul maxim al zilei	Nu are echivalent in MQL4
SYMBOL_BIDLOW	Bid-ul minim al zilei	Nu are echivalent in MQL4
SYMBOL_ASK	Ask – Cea mai buna oferta de vanzare (nivel II) sau pretul de cumparare (nivel I)	MODE_ASK
SYMBOL_ASKHIGH	Ask-ul maxim al zilei	Nu are echivalent in MQL4
SYMBOL_ASKLOW	Ask-ul minim al zilei	Nu are echivalent in MQL4
SYMBOL_LAST	Pretul ultimei tranzactii incheiate.	Nu are echivalent in MQL4
SYMBOL_LASTHIGH	Pretul maxim a ultimei tranzactii incheiate a zilei	Nu are echivalent in MQL4
SYMBOL_LASTLOW	Pretul minim al ultimei tranzactii incheiate a zilei	Nu are echivalent in MQL4
SYMBOL_POINT	Punctul matematic. De exemplu, daca o cotatie are 4 cifre, punctul este 1/10000 .	MODE_POINT
SYMBOL_TRADE_TICK_VALUE	Valoarea unui tick, pe un lot standard, in moneda contului. De exemplu este 1 la EURUSD, daca lotul este 100000, cu 5 cifre, sau 10, pentru 4 cifre. Pentru forex, este CONTRACT SIZE * TICK SIZE , considerat in a doua moneda din pereche si convertit mai departe in moneda contului. Pentru futures, este CONTRACT SIZE * POINT * TICK SIZE (ar trebui sa fie si convertit in moneda contului, dar e posibil sa nu fie…)	MODE_TICKVALUE
SYMBOL_TRADE_TICK_SIZE	Marimea unui tick. La forex, coincide cu POINT. La alte piete, difera.De exemplu la porumb futures este 0.25, intrucat este pasul minim de cotare.	MODE_TICKSIZE
SYMBOL_TRADE_ CONTRACT_SIZE	Marimea pentru un lot (lotul standard). De regula, pentru forex este de 100000 de unitati (la unii brokeri, atentie, 10000). Difera pentru futures.	MODE_LOTSIZE
SMBOL_VOLUME_MIN	Volumul minim al unei tranzactii	MODE_MINLOT
SYMBOL_VOLUME_MAX	Volumul maxim al unei tranzactii	MODE_MAXLOT
SYMBOL_VOLUME_STEP	Pasul volumului (volumul acceptabil al tranzactiei trebuie sa fie un multiplu de pas, dupa volumul minim)	MODE_LOTSTEP
SYMBOL_SWAP_LONG	Swap pentru pozitia long	MODE_SWAPLONG
SYMBOL_SWAP_SHORT	Swap pentru pozitia short	MODE_SWAPSHORT

SymbolInfoInteger()

Functia are acelasi prototip ca functia SymbolInfoDouble().

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

Identificator	Descriere	Tip	Echivalentul in MQL4
SYMBOL_SELECT	Simbolul este selectat in Market Watch	bool	Nu are echivalent in MQL4
SYMBOL_VOLUME	Volumul ultimei tranzactii	long	Nu are echivalent in MQL4
SYMBOL_VOLUMEHIGH	Volumul maxim al zilei	long	Nu are echivalent in MQL4
SYMBOL_VOLUMELOW	Volumul minim al zilei	long	Nu are echivalent in MQL4
SYMBOL_VOLUMEBID	Volumul pentru Bid-ul curent	long	Nu are echivalent in MQL4
SYMBOL_VOLUMEASK	Volumul pentru Ask-ul curent	long	Nu are echivalent in MQL4
SYMBOL_TIME	Timpul ultimei cotari	datetime	MODE_TIME
SYMBOL_DIGITS	Numarul de zecimale dupa punct (sau logaritm in baza 10 din inversul lui POINT)	int	MODE_DIGITS
SYMBOL_SPREAD	Valoarea spredului in puncte	int	MODE_SPREAD
SYMBOL_TICK_BOOKDEPTH	Adancimea pietei in nivele de stocare a cotatiilor.	long	Nu are echivalent in MQL4
SYMBOL_TRADE_CALC_MODE	Modul de calcul al profitului si marjei pentru contract	ENUM_ SYMBOL_ CALC_ MODE	Nu are echivalent in MQL4
SYMBOL_TRADE_MODE	Tipul de executie al ordinului	ENUM_ SYMBOL_ TRADE_ MODE	Nu are echivalent in MQL4
SYMBOL_TRADE_STOPS_LEVEL	Distanta minima acceptabila intre pretul curent si nivelul de Stop	int	MODE_STOPLEVEL
SYMBOL_TRADE_FREEZE_LEVEL	Nivelul de inghetare a ordinului, in puncte. Daca pretul de executie este in zona definita de nivelul de inghetare, ordinul nu poate modificat, anulat sau inchis.	int	MODE_FREEZELEVEL
SYMBOL_TRADE_EXEMODE	Modul de executie al tranzactiei	ENUM_ SYMBOL_ TRADE_ EXECUTION	Nu are echivalent in MQL4
SYMBOL_SWAP_MODE	Modelul de calcul al swapului	ENUM_ SYMBOL_ SWAP_ MODE	MODE_SWAPTYPE
SYMBOL_ROLLOVER3DAYS	Ziua in care swapul e triplu	ENUM_ DAY_OF_ WEEK	Nu are echivalent in MQL4

Tipul ENUM_SYMBOL_CALC_MODE descrie modul de calcul pentru marja si profit, dupa cum urmeaza:

Identificator	Descriere	Formula
SYMBOL_CALC_MODE_FOREX	Forex	Marja=LotsContract_Size/Leverage; Profit=(close_price-open_price)Contract_Size*Lots
SYMBOL_CALC_MODE_CFD	CFD	Marja=LotsContract_SizeMarket_PricePercentage/100; Profit=(close_price-open_price)Contract_Size*Lots
SYMBOL_CALC_MODE_FUTURES	Futures	Marja=LotsInitial_MarginPercentage/100; Profit=(close_price-open_price)Tick_Price/Tick_SizeLots
SYMBOL_CALC_MODE_CFDINDEX	Indice CFD	Marja=(LotsContract_SizeMarket_Price)Tick_Price/Tick_Size; Profit=(close_price-open_price)Contract_Size*Lots
SYMBOL_CALC_MODE_CFDLEVERAGE	CFD cu levier	Marja=(LotsContract_SizeMarket_PricePercentage)/Leverage; Profit=(close_price-open_price)Contract_Size*Lots

Tipul ENUM_SYMBOL_TRADE_MODE descrie ce fel de operatiuni sunt permise.

Identificator	Semnificatie
SYMBOL_TRADE_MODE_DISABLED	Tranzactionarea este oprita
SYMBOL_TRADE_MODE_LONGONLY	Se admite numai ca pozitia sa fie long
SYMBOL_TRADE_MODE_SHORTONLY	Se admite numai ca pozitia sa fie short
SYMBOL_TRADE_MODE_CLOSEONLY	Se admit numai operatiuni de inchidere a pozitiei
SYMBOL_TRADE_MODE_FULL	Trading nerestrictionat

Tipul ENUM_SYMBOL_TRADE_MODE descrie ce fel este executia.

Identificator	Semnificatie
SYMBOL_TRADE_EXECUTION_REQUEST	Executie la cerere.
SYMBOL_TRADE_EXECUTION_INSTANT	Executie instant.
SYMBOL_TRADE_EXECUTION_MARKET	Executie la piata

In masura in care Deviation ramane un parametru crucial pentru executie, ramane de vazut diferenta dintre cele trei moduri…

Tipul ENUM_SYMBOL_SWAP_MODE descrie in ce fel se aplica swapul.

Identificator	Semnificatie	Observatii
SYMBOL_SWAP_MODE_DISABLED	Fara swap
SYMBOL_SWAP_MODE_BY_POINTS	Swap in puncte
SYMBOL_SWAP_MODE_BY_MONEY	Swap in bani, cu valoarea specificata in moneda de depozit.	Probabil swap in moneda de depozit, pentru lotul standard.
SYMBOL_SWAP_MODE_BY_INTEREST	Swap in puncte procentuale anuale (model bancar, an de 360 de zile)	Formula e destul de clara, dar care e moneda?
SYMBOL_SWAP_MODE_BY_MARGIN_CURRENCY	Swap in bani, cu valoarea specificata in moneda marjei.	Probabil swap in moneda marjei, pentru lotul standard.

Totusi, MetaQuotes nu a indicat si formulele de calcul pentru swap. Swapul a fost o adevarata enigma in MT4, iar formulele de calcul au fost depistate pe incercate (in afara de tipul 2, pe care nu l-am acoperit in articolul din 2007 pe tema swapului). Se pare ca totusi de aceasta data vor fi mai simplu de extras, fara bataile de cap pe care le-am avut cu MT4.

Tipul ENUM_DAY_OF_WEEK cuprinde zilele saptamanii.

SymbolInfoString()

Functia are acelasi prototip ca functia SymbolInfoDouble().

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

Identificator	Descriere	Echivalentul in MQL4
SYMBOL_CURRENCY_BASE	Moneda de baza a simbolului	Nu are echivalent in MQL4
SYMBOL_CURRENCY_PROFIT	Moneda profitului	Nu are echivalent in MQL4
SYMBOL_CURRENCY_MARGIN	Moneda marjei. La forex, e prima moneda din pereche.	Nu are echivalent in MQL4
SYMBOL_BANK	Furnizorul cotatiei curente	Nu are echivalent in MQL4
SYMBOL_DESCRIPTION	Descrierea simbolului	Nu are echivalent in MQL4
SYMBOL_PATH	Calea in arborele de simboluri	Nu are echivalent in MQL4

SymbolInfoTick()

Functia SymbolInfoTick() are urmatorul prototip:

bool  SymbolInfoTick(
   string    symbol,     // simbol
   MqlTick&  tick        // referinta la o structura MqlTick
   );

Functia pune intr-o structura MqlTick datele cotatiei curente de piata.

Lucrul cu fisiere. Partea a III-a

Bogdan Baltatu, MQLmagazine editor — Sun, 28 Feb 2010 20:29:22 +0000

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

Acesta este al treilea articol din seria de articole intitulate ‘Lucrul cu fisiere’ si tin sa va anunt ca este unui dintre cele mai importante articole din serie deoarece voi prezenta atat functiile de scriere in fisiere cat si exemple prin care voi evidentia anumite aspecte ale functiilor.

Functiile care se refera strict la scrierea in fisiere sunt in numar de 8. Aceste functii sunt:

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

In continuarea articolului va voi prezenta fiecare functie in parte cu observatiile de rigoare. Acestea fiind spuse sa trecem la treaba.

FileWrite()

Functia se foloseste pentru scrierea datelor in fisiere de tip CSV. Prototipul functiei este:

uint  FileWrite(
   int  file_handle    // referinta fisierului
   ...                 // Lista cu parametrii de scris
   );

Parametrul file_handle reprezinta rezultatul intors de functia FileOpen() , functie care trebuie apelata cu flagurile FILE_CSV|FILE_WRITE. Daca fisierul nu este deschis cu flagul FILE_WRITE functia FileWrite() va esua.

Lista de parametri de scris in fisierul CSV nu poate fi mai mare de 63 , parametrii vor fi separati de delimitatorul specificat cand am deschis fisierul cu functia FileOpen(). Daca nu specificam delimitatorul atunci acesta va fi implicit caracterul ‘tab’ (ASCII 9).
Tipul parametrilor nu este specificat, ei putand fiind integer , datetime , float , … .Este important sa stim ca functia FileWrite() converteste in siruri de caractere parametrii primiti. Parametrii de tip double au 16 cifre dupa virgula , parametrii de tip float au 5 , iar parametrii de tip datetime sunt convertiti in formatul ‘YYYY.MM.DD HH:MI:SS’.
Fiecare comanda FileWrite() pune la sfarsitul stringului generat ‘\r\n’. Acest lucru arata ca imediat dupa scrierea stringului cursorul a fost mutat pe linia urmatoare la capat de rand.

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

In Excel 2007 , desi delimitatorul este ‘tab’ si parametrii de inregistrat ar trebui sa fie afisati pe cate o coloana separata ei nu apar. Daca redenumim fisierul ca fiind ‘.txt’ si il deschidem cu Excel 2007 atunci parametrii pe cate o coloana deorece recunoaste caracterul ‘tab’. Problema este din cauza Excel si nu merita studiata. Este recomandat sa deschideti fisierul CSV cu un editor precum notepad sau notepad++ in cazul in care are mai mult de 65535 linii.

FileWriteArray()

Functia scrie elementele din tablouri de diferite tipuri , cu exceptia celor de tip string , in fisiere deschise ca FILE_BIN.

Prototipul functiei este:

int  FileWriteArray(
int   file_handle                  // Referinta fisierului
void  array[],                     // Tabloul
int   start_item=0,             // Indexul elementului din tablou
int   items_count=WHOLE_ARRAY   // Numarul de elemente
);

Parametrii functiei sunt: file_handle , rezultatul intors de functia FileOpen(); array , tabloul din care extrag elementele pentru scrierea in fisier ; start_item , locul din tablou de unde incepe scrierea ; items_count , numarul de elemente pe pe care il copiez incepand de la start_item.

Rezultatul intors de functia FileWriteArray() este numarul de elemente scrise in fisier , rezultatul intors de functie trebuie sa fie egal cu items_count pentru ca functia sa fi avut o executie corecta.

Daca tabloul are 9 elemente si-i trimitem items_count mai mare ca 9 , functia FileWriteArray() nu va intoarce o eroare , ea va scrie cele 9 elemente.

Mai jos aveti un exemplu de cod care scrie o matrice intr-un fisier de tip bin (deschis cu FILE_BIN):

1
2
3

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

Tablourile de tip string trebuie scrise in fisiere TXT. Filecare element , la scrierea in fisier, este urmat de characterele ‘\r\n’ , deci fiecare element al matricei o sa fie scris pe o noua linie. Mai jos am exemplificat intr-un cod functionalitatea FileWriteArray() in cazul in care matricea pe care vreau sa o scriu este de tip string.

1
2
3

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

FileWriteDouble()

Functia scrie intr-un fisier la pozitia curenta a cursorului o valoare de tip double. Prototipul functiei este :

uint  FileWriteDouble(
   int     file_handle      // Referinta fisierului
   double  dvalue           // Valoarea pe care dorim sa o scriem
   );

Parametrii functiei sunt doi la numar: file_handle este referinta catre fisierul deschis intors de FileOpen() si dvalue este valoarea de tip double pe care dorim sa o scrie in fisier.

Functia se executa cu succes daca rezultatul intors este 8 , adica lungimea in bytes a unei variabile de tip double si pointerul se muta cu 8 bytes.

Mai jos aveti un exemplu de cod.

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

Atentie: Pentru a folosi functia FileWriteDouble() fisierul trebuie deschis in modul binar , altfel functia esueaza la executie.

FileWriteFloat()

Functia FileWriteFloat() este asemanatoare cu FileWriteDouble() , numai ca tipul de variabila pe care il scriem in fisier este de tip float. Prototipul functiei este:

uint  FileWriteFloat(
int    file_handle      // Referinta fisierului
float  fvalue           // Valoarea pe care dorim sa o scriem
);

Parametrii functiei sunt file_handle , referinta fisierului dat de functia FileOpen() si valoarea de tip float pe care dorim sa o scriem in fisierul nostru.

Exemplu de cod:

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

Desigur, rezultatul trebuie sa fie 4, lungimea in bytes a unei variabile de tip float, pentru o scriere corecta.

FileWriteInteger()

Functia scrie o variabila de tip integer intr-un fisier de tip bin incepand de la pozitia curenta a pointerului. Prototipul functiei este:

uint  FileWriteInteger(
int  file_handle          // referinta fisierului
int  ivalue,                // Valoare pe care dorim sa o scriem
int  size=INT_VALUE // Marimea in bytes
);

Parametrii functiei sunt : referinta fisierului , file_handle , valoarea pe care dorim sa o scriem in fisier si marimea ei in bytes.
Untimul parametru poate fi 1, 2 sau 4. (1=char , 2=short , 4=integer).
Functia intoarce 1,2 sau 4 in functie de parametrul size si anume valoarea intoarsa trebuie sa fie egala cu acesta, daca functia s-a executat corect.

Exemplu de cod:

1
2
3

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

Fisierul trebuie deschis ca bin neaparat , altfel functia da eroare. Daca functia a fost executata cu succes pointerul se muta cu cati bytes returneaza functia (1,2 sau 4).

Trebuie sa precizam ca prin 'int' in antetul functiei compilatorul intelege orice tip intreg, iar functia nu presupune intregi cu semn, putand lucra si cu intregi fara semn.

FileWriteLong()

Functia scrie o valoare long intr-un fisier bin incepand cu pozitia curenta a cursorului in fisier. Prototipul functiei este:

uint  FileWriteLong(
int   file_handle      // Referinta fisierului
long  lvalue           // Valoarea pe care dorim sa o scriem
);

Parametrii functiei sunt : referinta fisierului intors de functia FileOpen() si valoarea pe care dorim sa o scriem.
Daca functia se executa cu succes intoarce 8 , lungimea in bytes a unei variabile de tip long.

Exemplu de cod:

1
2
3

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

FileWriteString()

Functia scrie un string intr-un fisier de tip txt sau bin incepand de la pozitia curenta a cursorului. Prototipul functiei este:

uint  FileWriteString(
   int     file_handle      // Referinta fisierului
   string  svalue,         // Stringul pe care doresc sa il scriu
   int     size=-1          // Numarul de simboluri
   );

Parametrii functiei sunt: referinta fisierului , stringul pe care dorim sa il scriem si numarul de caractere pe care il contine stringul.
Al treilea parametru este obligatoriu in cazul in care fisierul a fost deschis cu FILE_BIN , dar optional cand fisierul a fost deschis ca FILE_TXT.

Daca executia functiei reuseste atunci rezultatul este numarul de bytes scris in fisier si pozitie cursorului se deplaseaza cu numarul de bytes scrisi in fisier.

De precizat ar fi ca atunci cand folosim functia pentru a scrie intr-un fisier deschis cu FILE_UNICODE (specificat sau nu, caci FILE_UNICODE e default) numarul de bytes scrisi este de 2 ori mai mare decat numarul de caractere. Cand scriem cu flagul FILE_ANSI numarul de bytes scrisi coincide cu numarul de caractere. E cel putin ciudata decizia MetaQuotes sa faca FILE_UNICODE default in loc de FILE_ANSI. Normal ar fi ca FILE_ANSI sa fie default, pentru a evita dublarea inutila a marimii fisierelor text, stiindu-se ca userii in marea majoritate le vor deschide cu Notepad sau Excel.

Exemplu de cod:

1
2
3

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

FileWriteStruct()

Functia scrie intr-un fisier de tip bin continutul unei structuri parsat ca un parametru incepand cu pozitia curenta a cursorului. Prototipul functiei este:

uint  FileWriteStruct(
int                file_handle      // Referinta fisierului
any_simple_struct  str_object&,     // Link catre obiectul de tip struct
int                size             // Marimea care o sa fie scrisa in bytes
);

Parametrii functiei sunt: referinta fisierului intoarsa de functia FileOpen() , variabila de tip structura (trimisa prin referinta) si marimea in bytes pe care dorim sa o scriem. Daca functia este executata cu succes returneaza numarul de bytes scris.

Exemplu de cod:

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

Cand definim structura 'a' trebuie sa o definesc ca pe un tablou , ca sa pot sa scriu in structura cu functia CopyRates() si trebuie neaparat sa o definesc ca avand cel putin un element.

De precizat ca in fisierele deschise cu FILE_BIN in care am scris ceva daca le deschidem o sa vedem niste caractere ciudate. Sa nu credeti ca valoarea pe care am vrut sa o scriem a fost scrisa gresit. Desi fisierele sunt bin le-am salvat ca fiind '.txt' pentru a putea sa le deschideti usor cu editorul text si sa vedeti ca ceva s-a fost scris.

Se pare ca MetaQuotes a ales o cale complicata pentru fisiere. Voi face o scurta trecere in revista a felului in care Borland Pascal cunostea fisierele, doar ca sa vedeti ce simplu era la vremea aceea (anii '90).
Mai intai, Borland Pascal nu avea conceptul de referinta de fisier , de numar care sa il identifice. Avea doar variabile de tip fisier. Acestea erau variabile complexe, cunoscute doar de compilator - nu se puteau citi, scrie sau interoga. Functiile de citire/scriere erau cam 6 la numar , si anume: ReadLn, WriteLn, Read, Write, BlockRead, BlockWrite. ReadLn si WriteLn lucrau doar cu ecranul, tastatura si fisierele text, in vreme ce Read si Write lucrau si la nivel "binar". Datorita naturii speciale a variabilelor fisier, Read si Write stiau daca au operatiune I/O cu tastatura/ecranul sau cu un fisier. Nu era nevoie de FileRead sau FileWrite, intrucat daca primul parametru era o variabila fisier, el nu putea fi luat drept integer sau altceva - functiile stiau din start cu ce lucrau. Daca era file of text , si scriai Write(f,128) , functia ar fi scris "128" , text , pe 3 caractere, iar daca era file of byte, functia ar fi scris un byte cu valoarea 128.
De asemenea, definirea stricta a variabilelor facea diferenta dintre tipurile de variabile si functiile stiau din start cati bytes au de citit/scris pentru fiecare tip de date. Daca fisierul avea un tip complex, gen file of record (record era echivalentul struct din MQL5), atunci functiile citeau si scriau una sau mai multe structuri la rand, incrementand pozitia in fisier cu numarul de structuri, nu cu numarul de bytes. BlockRead si BlockWrite lucrau cu orice fel de variabile, fiind interesate numai in lungimea blocurilor citite/scrise (functionau pe fisiere fara tip).

Multa atentie cand folositi functiile de fisiere. Altfel, puteti pierde timp inregistrand date care sunt salvate gresit in fisiere!