Adaptive Trading Systems

http://www.mql5.com/en/articles/143

//+------------------------------------------------------------------+

//|                                                  CStrategyMA.mqh |

//|                        Copyright 2010, MetaQuotes Software Corp. |

//|                                              http://www.mql5.com |

//+------------------------------------------------------------------+

#property copyright "Copyright 2010, MetaQuotes Software Corp."

#property link      "http://www.mql5.com"

#include <CSampleStrategy.mqh>

//+------------------------------------------------------------------+

//| Class CStrategyMA for implementation of virtual trading          |

//| by the strategy based on moving average                          |

//+------------------------------------------------------------------+

class CStrategyMA : public CSampleStrategy

  {

protected:

   int               m_handle;     // handle of the Moving Average (iMA) indicator

   int               m_period;     // period of the Moving Average indicator

   double            m_values[];   // array for storing values of the indicator

public:

   // initialization of the strategy

   int               Initialization(int period,bool virtual_trade_flag);

   // deinitialization of the strategy

   int               Deinitialization();

   // checking trading conditions and opening virtual positions

   bool              CheckTradeConditions();

  };

//+------------------------------------------------------------------+

//| Strategy Initialization Method                                   |

//+------------------------------------------------------------------+

int CStrategyMA::Initialization(int period,bool virtual_trade_flag)

  {

   // set period of the moving average

   m_period=period;

   // set specified flag of virtual trading

   SetVirtualTradeFlag(virtual_trade_flag);

   //set indexation of arrays like the one of timeseries

   ArraySetAsSeries(m_rates,true);

   ArraySetAsSeries(m_values,true);

   //create handle of the indicator

   m_handle=iMA(_Symbol,_Period,m_period,0,MODE_EMA,PRICE_CLOSE);

   if(m_handle<0)

     {

      Alert("Error of creation of the MA indicator - error number: ",GetLastError(),"!!");

      return(-1);

     }

   return(0);

  }

//+------------------------------------------------------------------+

//| Strategy Deinitialization Method                                 |

//+------------------------------------------------------------------+

int CStrategyMA::Deinitialization()

  {

   Position_CloseOpenedPosition(m_position);

   IndicatorRelease(m_handle);

   return(0);

  };

//+------------------------------------------------------------------+

//| Checking trading conditions and opening virtual positions        |

//+------------------------------------------------------------------+

bool CStrategyMA::CheckTradeConditions()

  {

   RecalcPositionProperties(m_position);

   double p_close;

   // get history data of the last three bars

   if(CopyRates(_Symbol,_Period,0,3,m_rates)<0)

     {

      Alert("Error of copying history data - error:",GetLastError(),"!!");

      return(false);

     }

   // Copy the current price of closing of the previous bar (it is bar 1)

   p_close=m_rates[1].close;  // close price of the previous bar          

   if(CopyBuffer(m_handle,0,0,3,m_values)<0)

     {

      Alert("Error of copying buffers of the Moving Average indicator - error number:",GetLastError());

      return(false);

     }

   // buy condition 1: MA rises

   bool buy_condition_1=(m_values[0]>m_values[1]) && (m_values[1]>m_values[2]);

   // buy condition 2: previous price is greater than the MA

   bool buy_condition_2=(p_close>m_values[1]);

   // sell condition 1: // MA falls

   bool sell_condition_1=(m_values[0]<m_values[1]) && (m_values[1]<m_values[2]);

   // sell condition 2: // previous price is lower than the MA   

   bool sell_condition_2=(p_close<m_values[1]);

   int new_state=0;

   if(buy_condition_1  &&  buy_condition_2) new_state=SIGNAL_OPEN_LONG;

   if(sell_condition_1 && sell_condition_2) new_state=SIGNAL_OPEN_SHORT;

   if((GetSignalState()==SIGNAL_OPEN_SHORT) && (buy_condition_1 || buy_condition_2)) new_state=SIGNAL_CLOSE_SHORT;

   if((GetSignalState()==SIGNAL_OPEN_LONG) && (sell_condition_1 || sell_condition_2)) new_state=SIGNAL_CLOSE_LONG;

   if(GetSignalState()!=new_state)

     {

      SetSignalState(new_state);

     }

   return(true);

  };

=========================================================================

//+------------------------------------------------------------------+//|                                              CSampleStrategy.mqh |//|                        Copyright 2010, MetaQuotes Software Corp. |//|                                              http://www.mql5.com |//+------------------------------------------------------------------+#property copyright "Copyright 2010, MetaQuotes Software Corp."#property link      "http://www.mql5.com"#include <Object.mqh>#define POSITION_NEUTRAL   0     // no position#define POSITION_LONG      1     // long position#define POSITION_SHORT    -1     // short position#define SIGNAL_OPEN_LONG    10   // signal to open a long position#define SIGNAL_OPEN_SHORT  -10   // signal to open a short position#define SIGNAL_CLOSE_LONG   -1   // signal to close a long position#define SIGNAL_CLOSE_SHORT   1   // signal to close a short position//+------------------------------------------------------------------+//| Structure for storing the parameters of virtual position         |//+------------------------------------------------------------------+struct virtual_position   {    string            symbol;            // symbol    int               direction;         // direction of the virtual position (0-no open position,+1 long,-1 short)    double            volume;            // volume of the position in lots    double            profit;            // current profit of the virtual position on points    double            stop_loss;         // Stop Loss of the virtual position    double            take_profit;       // Take Profit of the virtual position    datetime          time_open;         // date and time of opening the virtual position    datetime          time_close;        // date and time of closing the virtual position    double            price_open;        // open price of the virtual position    double            price_close;       // close price of the virtual position    double            price_highest;     // maximum price during the life of the position    double            price_lowest;      // minimal price during the lift of the position    double            entry_eff;         // effectiveness of entering    double            exit_eff;          // effectiveness of exiting    double            trade_eff;         // effectiveness of deal   }; //+------------------------------------------------------------------+//| Class CSampleStrategy                                            |//+------------------------------------------------------------------+class CSampleStrategy: public CObject   { protected:    int               m_strategy_id;            // Strategy ID    string            m_strategy_symbol;        // Symbol    string            m_strategy_name;          // Strategy name    string            m_strategy_comment;       // Comment     MqlTick           m_price_last;             // Last price    MqlRates          m_rates[];                // Array for current quotes    bool              m_virtual_trade_allowed;  // Flag of allowing virtual trading    int               m_current_signal_state;   // Current state of strategy    double            m_current_trade_volume;   // Number of lots for trading    double            m_initial_balance;        // Initial balance (set in the constructor, default value is 10000)    int               m_sl_points;              // Stop Loss    int               m_tp_points;              // Take Profit     virtual_position  m_position;               // Virtual position    virtual_position  m_deals_history[];        // Array of deals    int               m_virtual_deals_total;    // Total number of deals     double            m_virtual_balance;           // "Virtual" balance    double            m_virtual_equity;            // "Virtual" equity    double            m_virtual_cumulative_profit; // cumulative "virtual" profit    double            m_virtual_profit;            // profit of the current open "virtual" position     //checks and closes the virtual position by stop levels if it is necessary    bool              CheckVirtual_Stops(virtual_position &position);    // recalculation of position and balance    void              RecalcPositionProperties(virtual_position &position);    // recalculation of open virtual position in accordance with the current prices    void              Position_RefreshInfo(virtual_position &position);    // open virtual short position    void              Position_OpenShort(virtual_position &position);    // closes virtual short position      void              Position_CloseShort(virtual_position &position);    // opens virtual long position    void              Position_OpenLong(virtual_position &position);    // closes the virtual long position    void              Position_CloseLong(virtual_position &position);    // closes open virtual position      void              Position_CloseOpenedPosition(virtual_position &position);    // adds closed position to the m_deals_history[] array (history of deals)    void              AddDealToHistory(virtual_position &position);    //calculates and returns the recommended volume that will be used in trading    virtual double    MoneyManagement_CalculateLots(double trade_volume); public:    // constructor    void              CSampleStrategy();    // destructor    void             ~CSampleStrategy();     //returns the current size of virtual balance    double            GetVirtualBalance() { return(m_virtual_balance); }    //returns the current size of virtual equity    double            GetVirtualEquity() { return(m_virtual_equity); }    //returns the current size of virtual profit of open position    double            GetVirtualProfit() { return(m_virtual_profit); }     //sets Stop Loss and Take Profit in points    void              Set_Stops(int tp,int sl) {m_tp_points=tp; m_sl_points=sl;};    //sets the current volume in lots    void              SetLots(double trade_volume) {m_current_trade_volume=trade_volume;};    //returns the current volume in lots    double            GetCurrentLots() { return(m_current_trade_volume); }     // returns strategy name    string            StrategyName() { return(m_strategy_name); }    // returns strategy ID    int               StrategyID() { return(m_strategy_id); }    // returns the comment of strategy    string            StrategyComment() { return(m_strategy_comment); }    // sets the details of strategy (symbol, name and ID of strategy)    void              SetStrategyInfo(string symbol,string name,int id,string comment);     // set the flag of virtual trading (allowed or not)    void              SetVirtualTradeFlag(bool pFlag) { m_virtual_trade_allowed=pFlag; };    // returns flag of allowing virtual trading    bool              IsVirtualTradeAllowed() { return(m_virtual_trade_allowed); };     // returns the current state of strategy    int               GetSignalState();    // sets the current state of strategy (changes virtual position if necessary)    void              SetSignalState(int state);    // changes virtual position in accordance with the current state    void              ProceedSignalState(virtual_position &position);     // sets the value of cumulative "virtual" profit    void              SetVirtualCumulativeProfit(double cumulative_profit) { m_virtual_cumulative_profit=cumulative_profit; };     //returns the effectiveness of strategy ()    double            StrategyPerformance();     //updates position data    void              UpdatePositionData();    //closes open virtual position    void              CloseVirtualPosition();    //returns the direction of the current virtual position    int               PositionDirection();    //virtual function of initialization    virtual int       Initialization() {return(0);};    //virtual function of checking trade conditions    virtual bool      CheckTradeConditions() {return(false);};    //virtual function of deinitialization    virtual int       Deinitialization() {return(0);};     //saves virtual deals to a file    void              SaveVirtualDeals(string file_name);   };

//+------------------------------------------------------------------+ //| Constructor of the CSampleStrategy class                         | //+------------------------------------------------------------------+ void CSampleStrategy::CSampleStrategy()   {    ZeroMemory(m_position);              // clear m_position    m_virtual_cumulative_profit=0;       // cumulative virtual profit    m_virtual_profit=0;                  // virtual profit    m_current_trade_volume=0.1;          // default volume in lots    m_strategy_id=0;                     // default ID=0    m_strategy_name="Sample Strategy";   // default is "Sample Strategy"    m_current_signal_state=0;            // current state of strategy    m_virtual_trade_allowed=true;        // virtual trading is allowed on default    m_initial_balance=10000;             // initial virtual balance    m_virtual_balance=m_initial_balance; // current virtual balance    m_virtual_equity=m_initial_balance;  // current virtual equity    m_sl_points=0;                       // default Stop Loss value (in points)    m_tp_points=0;                       // default Take Profit value (in points)   } //+------------------------------------------------------------------+ //| Destructor of the CSampleStrategy class                          | //+------------------------------------------------------------------+  void CSampleStrategy::~CSampleStrategy()   { //zeroize array sizes    ArrayResize(m_rates,0);    ArrayResize(m_deals_history,0);   } //+------------------------------------------------------------------+ //| Function of updating position data                               | //+------------------------------------------------------------------+ void CSampleStrategy::UpdatePositionData()   {    RecalcPositionProperties(m_position);   } //+------------------------------------------------------------------+ //| Function of closing virtual position                             | //+------------------------------------------------------------------+ void CSampleStrategy::CloseVirtualPosition()   {    Position_CloseOpenedPosition(m_position);   } //+------------------------------------------------------------------+ //| Returns current direction of position                            | //+------------------------------------------------------------------+ int CSampleStrategy::PositionDirection()   {    return(m_position.direction);   } //+------------------------------------------------------------------+ //| Function returns the recommended volume for strategy in lots     | //| The current volume is passed to it a a parameter                 | //| Volume can be set depending on:                                  | //| current m_virtual_balance and m_virtual_equity                   | //| current statistics of deals (that is stored in m_deals_history)  | //| or any other thing you want                                      | //| If the change of volume is not required in the strategy          | //| we can  return the passed volume:  return(trade_volume);         | //+------------------------------------------------------------------+  double CSampleStrategy::MoneyManagement_CalculateLots(double trade_volume)   { //return what has been obtained     return(trade_volume);   } //+------------------------------------------------------------------+ //| The StrategyPerformance function of effectiveness of strategy    | //+------------------------------------------------------------------+  double CSampleStrategy::StrategyPerformance()   { //returns the effectiveness of strategy //in this case it's the difference between the amount  //of equity at the moment and the initial balance  //i.e. how much money the strategy has earned    double performance=(m_virtual_equity-m_initial_balance);    return(performance); /*   //if there were deals performed,  then multiple the result of three next deals by this value    if(m_virtual_deals_total>0)      {       int avdeals=MathRound(MathMin(3,m_virtual_deals_total));       double sumprofit=0;       for(int j=0; j<avdeals; j++)         {          sumprofit+=m_deals_history[m_virtual_deals_total-1-j].profit;         }       sumprofit=sumprofit/avdeals;       performance=performance*sumprofit;      }      return(performance); */   } //+------------------------------------------------------------------+ //| Set the details of strategy (name, ID, comment)                  | //+------------------------------------------------------------------+ void  CSampleStrategy::SetStrategyInfo(string symbol,string name,int id,string comment)   {    //symbols    m_strategy_symbol=symbol;    //ID    m_strategy_id=id;    //name    m_strategy_name=name;    //comment    m_strategy_comment=comment;   //symbol of position    m_position.symbol=m_strategy_symbol;   } //+------------------------------------------------------------------+ //| "Closes" the current open virtual position,                      | //| copies its parameters and adds                                   | //| it to the array of virtual deals m_deals_history                 | //+------------------------------------------------------------------+ void  CSampleStrategy::AddDealToHistory(virtual_position &position)   {    //request the size of the array of virtual deals    m_virtual_deals_total=ArraySize(m_deals_history);    //increase it by 1    m_virtual_deals_total++;    //increase the size of array m_deals_history by 1    ArrayResize(m_deals_history,m_virtual_deals_total);    //copy the position properties to the last element of the array    m_deals_history[m_virtual_deals_total-1].symbol=position.symbol;    m_deals_history[m_virtual_deals_total-1].direction=position.direction;    m_deals_history[m_virtual_deals_total-1].volume=position.volume;    m_deals_history[m_virtual_deals_total-1].stop_loss=position.stop_loss;    m_deals_history[m_virtual_deals_total-1].take_profit=position.take_profit;    m_deals_history[m_virtual_deals_total-1].profit = position.profit;    m_deals_history[m_virtual_deals_total-1].volume = position.volume;    m_deals_history[m_virtual_deals_total-1].time_open=position.time_open;    m_deals_history[m_virtual_deals_total-1].time_close = position.time_close;    m_deals_history[m_virtual_deals_total-1].price_open = position.price_open;    m_deals_history[m_virtual_deals_total-1].price_close= position.price_close;    m_deals_history[m_virtual_deals_total-1].price_highest= position.price_highest;    m_deals_history[m_virtual_deals_total-1].price_lowest = position.price_lowest;    m_deals_history[m_virtual_deals_total-1].entry_eff= position.entry_eff;    m_deals_history[m_virtual_deals_total-1].exit_eff = position.exit_eff;    m_deals_history[m_virtual_deals_total-1].trade_eff= position.trade_eff;    //current profit of position    m_virtual_profit=position.profit;    //increase the cumulative profit by the size of the position that is cosed    m_virtual_cumulative_profit=m_virtual_cumulative_profit+m_virtual_profit;    //zeroize the direction of position (no position)    position.direction=0;    //zeroize the profit of position    position.profit=0;   } //+----------------------------------------------------------------------+ //| Checks and closes virtual position by stop levels if it is necessary | //+----------------------------------------------------------------------+ bool CSampleStrategy::CheckVirtual_Stops(virtual_position &position)   {    if(position.direction==0) {return(false);}    //if there is a position, check if it should be closed by stop levels    if(position.direction==POSITION_LONG)      {       if((position.stop_loss>0.0) && (position.price_close<=position.stop_loss))         {          //Print("Close LONG: Stop Loss: ",position.stop_loss," Price:",position.price_close);          Position_CloseLong(position);          return(true);         }       if((position.take_profit>0.0) && (position.price_close>=position.take_profit))         {          //Print("Close LONG: Take Profit: ",position.take_profit," Price:",position.price_close);          Position_CloseLong(position);          return(true);         };      }    if(position.direction==POSITION_SHORT)      {       if((position.stop_loss>0.0) && (position.price_close>=position.stop_loss))         {          //Print("Close SHORT: Stop Loss: ",position.stop_loss," Price:",position.price_close);          Position_CloseShort(position);          return(true);         }       if((position.take_profit>0.0) && (position.price_close<=position.take_profit))         {          //Print("Close SHORT: ",position.take_profit," Price:",position.price_close);          Position_CloseShort(position);          return(true);         }      }    return(false);   } //+------------------------------------------------------------------+ //| Recalculates parameters of open virtual position                 | //+------------------------------------------------------------------+ void CSampleStrategy::Position_RefreshInfo(virtual_position &position)   {    //request the last quotes by the symbols of position    SymbolInfoTick(position.symbol,m_price_last);     //if there is a position, recalculate its parameters    if(position.direction!=0)      {       position.time_close=0;       position.price_highest=MathMax(position.price_highest,m_price_last.ask);       position.price_lowest=MathMin(position.price_lowest,m_price_last.bid);        double xfactor;       if((position.price_highest-position.price_lowest)==0)         {          //Print("BID=ASK?","Bid=",m_price_last.bid," Ask=",m_price_last.ask);          return;         }       xfactor=1.0/(position.price_highest-position.price_lowest);        //for a long position       if(position.direction==POSITION_LONG)         {          position.price_close=m_price_last.bid;          position.entry_eff=(position.price_highest-position.price_open)*xfactor;          position.exit_eff=(position.price_close-position.price_lowest)*xfactor;          position.trade_eff=(position.price_close-position.price_open)*xfactor;          position.profit=position.volume*(position.price_close-position.price_open)/_Point;         }       //for a short position       if(position.direction==POSITION_SHORT)         {          position.price_close=m_price_last.ask;          position.entry_eff=(position.price_open-position.price_lowest)*xfactor;          position.exit_eff=(position.price_highest-position.price_close)*xfactor;          position.trade_eff=(position.price_open-position.price_close)*xfactor;          position.profit=position.volume*(position.price_open-position.price_close)/_Point;         }       CheckVirtual_Stops(position);      }   } //+------------------------------------------------------------------------+ //| Recalculation of the properties of position and of the current balance | //+------------------------------------------------------------------------+ void CSampleStrategy::RecalcPositionProperties(virtual_position &position)   {    //Refresh the parameters of open position    Position_RefreshInfo(m_position);    // if the position is open, refresh the profit    if(m_position.direction!=0)      {       m_virtual_profit=m_position.profit;      }    //string s1="RecalcPositionProperties:"+StrategyName()+" "+m_virtual_equity+" Balance="+m_virtual_balance+" m_virtual_cumulative_profit="+m_virtual_cumulative_profit+" "+m_virtual_profit;     //refresh the values of equity and balance    m_virtual_equity=m_initial_balance+m_virtual_cumulative_profit+m_virtual_profit;    m_virtual_balance=m_initial_balance+m_virtual_cumulative_profit;     //   s1=s1+" new value="+m_virtual_equity+" new balance="+m_virtual_balance;      //   Print(s1);   } //+------------------------------------------------------------------+ //| Closes open short position                                       | //+------------------------------------------------------------------+ void CSampleStrategy::Position_CloseShort(virtual_position &position)   {    //exit if the virtual trading is prohibited    if(!m_virtual_trade_allowed) {return;}    //exit if the direction of virtual position doesn't correspond with POSITION_SHORT    if(position.direction!=POSITION_SHORT){return;}    //fix the time of closing the virtual position    position.time_close=TimeCurrent();    //add the deal to the history and close the virtual position    AddDealToHistory(position);   } //+------------------------------------------------------------------+ //| Opens virtual long position                                      | //+------------------------------------------------------------------+ void CSampleStrategy::Position_OpenLong(virtual_position &position)   {    //exit if the virtual trading is prohibited    if(!m_virtual_trade_allowed) {return;}    //set the direction of the virtual position    position.direction=POSITION_LONG;     // calculate the volume according to Money Management    m_current_trade_volume=MoneyManagement_CalculateLots(m_current_trade_volume);    //set volume of the virtual position    position.volume=m_current_trade_volume;     //set the time of opening the virtual position    position.time_open=TimeCurrent();    //set the price of opening the virtual position       position.price_open=m_price_last.ask;     //set Stop Loss of the virtual sell position    if(m_sl_points>0) position.stop_loss=position.price_open+m_sl_points*_Point; else position.stop_loss=0;    //set Take Profit of the virtual sell position    if(m_tp_points>0) position.take_profit=position.price_open-m_tp_points*_Point; else position.take_profit=0;     //Print("Position_OpenLong: SL=",position.stop_loss," TP=",position.take_profit);     //set the current price of closing the virtual position (for the convenience of calculation)      position.price_close=m_price_last.bid;    //set the time of closing the virtual position    position.time_close=0;    //calculate profit    position.profit=position.volume*(position.price_close-position.price_open)/_Point;    //set the maximum price    position.price_highest=m_price_last.ask;    //set the minimum price    position.price_lowest=m_price_last.bid;    //update the properties of position in correspondence with the prices    RecalcPositionProperties(position);   } //+------------------------------------------------------------------+ //| Close the virtual buy position                                   | //+------------------------------------------------------------------+ void CSampleStrategy::Position_CloseLong(virtual_position &position)   {    //exit if the virtual trading is prohibited    if(!m_virtual_trade_allowed) {return;}    //exit if the direction of virtual position doesn't correspond with POSITION_LONG    if(position.direction!=POSITION_LONG){return;}    //fix the time of closing the virtual position    position.time_close=TimeCurrent();    //add the deal to the history and close the virtual position    AddDealToHistory(position);   } //+------------------------------------------------------------------+ //| Opens virtual sell position                                      | //+------------------------------------------------------------------+ void CSampleStrategy::Position_OpenShort(virtual_position &position)   {    //exit if the virtual trading is prohibited    if(!m_virtual_trade_allowed) {return;}    //set the direction of the virtual position    position.direction=POSITION_SHORT;     // calculate the volume according to Money Management    m_current_trade_volume=MoneyManagement_CalculateLots(m_current_trade_volume);    //set volume of the virtual position    position.volume=m_current_trade_volume;     //set the time of opening the virtual position    position.time_open=TimeCurrent();    //set the price of opening the virtual position    position.price_open=m_price_last.bid;    //set the current price of closing the virtual position (for the convenience of calculation)      position.price_close=m_price_last.ask;     //set Stop Loss of the virtual sell position    if(m_sl_points>0) position.stop_loss=position.price_open+m_sl_points*_Point; else position.stop_loss=0;    //set Take Profit of the virtual sell position    if(m_tp_points>0) position.take_profit=position.price_open-m_tp_points*_Point; else position.take_profit=0;     //Print("Position_OpenShort: SL=",position.stop_loss," TP=",position.take_profit);     //set the time of closing the virtual position    position.time_close=0;    //calculate profit    position.profit=position.volume*(position.price_open-position.price_close)/_Point;    //set the maximum price    position.price_highest=m_price_last.ask;    //set the minimum price    position.price_lowest=m_price_last.bid;    //update the properties of position in correspondence with the prices    RecalcPositionProperties(position);   } //+------------------------------------------------------------------+ //| Closes open virtual position                                     | //+------------------------------------------------------------------+ void CSampleStrategy::Position_CloseOpenedPosition(virtual_position &position)   {    if(position.direction!=POSITION_NEUTRAL)      {       if(position.direction==POSITION_SHORT) Position_CloseShort(position);       if(position.direction==POSITION_LONG)  Position_CloseLong(position);      }   } //+------------------------------------------------------------------+ //| Changes the "position" position in accordance with               | //| the value of m_current_signal_state                              | //+------------------------------------------------------------------+ void  CSampleStrategy::ProceedSignalState(virtual_position &position)   {    if(position.direction!=POSITION_NEUTRAL) // these is an open virtual position      {       switch(m_current_signal_state)         {          case SIGNAL_CLOSE_SHORT:   { Position_CloseShort(position); break; }          case SIGNAL_CLOSE_LONG:    { Position_CloseLong(position); break;}         }      }    else                             // no open virtual position      {       switch(m_current_signal_state)         {          case SIGNAL_OPEN_LONG:   { Position_OpenLong(position); break; }          case SIGNAL_OPEN_SHORT:  { Position_OpenShort(position); break;}         }      }   } //+------------------------------------------------------------------+ //| Returns the current state of strategy                            | //+------------------------------------------------------------------+ int CSampleStrategy::GetSignalState()   { return(m_current_signal_state); } //+------------------------------------------------------------------+ //| Sets the current state of strategy                               | //| changes the virtual position if necessary                        | //+------------------------------------------------------------------+ void  CSampleStrategy::SetSignalState(int state)   {    if(m_current_signal_state!=state)      {       m_current_signal_state=state;       ProceedSignalState(m_position);      }   }; //+------------------------------------------------------------------+ //| Save all performed  virtual deals to a file                      | //+------------------------------------------------------------------+ void CSampleStrategy::SaveVirtualDeals(string file_name)   {    //exit if there has been no trades    if(m_virtual_deals_total==0) {return;};    //open a file for writing    int filehandle=FileOpen(file_name,FILE_WRITE|FILE_CSV);    //write headers of columns    FileWrite(filehandle,              "Symbol",              "Direction",              "Profit",              "Volume",              "OpenTime",              "CloseTime",              "OpenPrice",              "ClosePrice",              "HighestPrice",              "LowestPrice",              "Entry_Eff",              "Exit_Eff",              "Trade_Eff");    //save all deals    for(int i=0; i<m_virtual_deals_total; i++)      {       FileWrite(filehandle,                 m_deals_history[i].symbol,                 m_deals_history[i].direction,                 m_deals_history[i].profit,                 m_deals_history[i].volume,                 m_deals_history[i].time_open,                 m_deals_history[i].time_close,                 m_deals_history[i].price_open,                 m_deals_history[i].price_close,                 m_deals_history[i].price_highest,                 m_deals_history[i].price_lowest,                 m_deals_history[i].entry_eff,                 m_deals_history[i].exit_eff,                 m_deals_history[i].trade_eff);      }    FileClose(filehandle);   } //+------------------------------------------------------------------+ //|Function of checking if a new bar has appeared                    | //+------------------------------------------------------------------+ bool IsNewBar()   {    static datetime old_time;    datetime new_time[1];    int copied=CopyTime(_Symbol,_Period,0,1,new_time);    if(copied>0)      {       if(old_time!=new_time[0])         {          old_time=new_time[0];          return(true);         }      }    else      {       Alert("Error of copying the time, error number =",GetLastError());       ResetLastError();      }    return(false);   } //+------------------------------------------------------------------+