Breakout15_v1





//+------------------------------------------------------------------+
//|                                                   BreakOut15.mq4 |
//|                                                 Copyright © 2006 |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, Robert Hill"

// DISCLAIMER ***** IMPORTANT NOTE ***** READ BEFORE USING ***** 
// This expert advisor can open and close real positions and hence do real trades and lose real money.
// This is not a 'trading system' but a simple robot that places trades according to fixed rules.
// The author has no pretentions as to the profitability of this system and does not suggest the use
// of this EA other than for testing purposes in demo accounts.
// Use of this system is free - but u may not resell it - and is without any garantee as to its
// suitability for any purpose.
// By using this program you implicitly acknowledge that you understand what it does and agree that 
// the author bears no responsibility for any losses.
// Before using, please also check with your broker that his systems are adapted for the frequest trades
// associated with this expert.
//
// Added code for 3 level trailing stop to protect profits

#include <stdlib.mqh>
//----
int SignalTimeFrame=15;
//+---------------------------------------------------+
//|Money Management                                   |
//+---------------------------------------------------+
extern bool MoneyManagement=true;       // Change to false if you want to shutdown money management controls.
                                        // Lots = 1 will be in effect and only 1 lot will be open regardless of equity.
extern double TradeSizePercent=10;      // Change to whatever percent of equity you wish to risk.
extern double Lots=1;                   
double MaxLots=100;
extern double TakeProfit=0;             // number of ticks to take profit. normally is = grid size but u can override
extern double StopLoss=60;              // if u want to add a stop loss. normal grids dont use stop losses
extern bool UseTrailingStop=true;
extern int TrailingStopType=2;          // Type 1 moves stop immediately, Type 2 waits til value of TS is reached
extern double TrailingStop=45;          // Change to whatever number of pips you wish to trail your position with.
extern double TRStopLevel_1=20;         // Type 3  first level pip gain
extern double TrailingStop1=15;         // Move Stop to Breakeven
extern double TRStopLevel_2=30;         // Type 3 second level pip gain
extern double TrailingStop2=20;         // Move stop to lock is profit
extern double TRStopLevel_3=40;
extern double TrailingStop3=20;         // Move stop and trail from there
extern int FastMA_Mode=1;               //0=sma, 1=ema, 2=smma, 3=lwma, 4=LSMA
extern int FastMA_Period=  10;
extern int FastMA_Shift=0;
extern int FastMA_AppliedPrice=0;       // 0=close, 1=open, 2=high, 3=low, 4=median((h+l/2)), 5=typical((h+l+c)/3), 6=weighted((h+l+c+c)/4)
extern int SlowMA_Mode=1;               //0=sma, 1=ema, 2=smma, 3=lwma, 4=LSMA
extern int SlowMA_Period=  80;
extern int SlowMA_Shift=0;
extern int SlowMA_AppliedPrice=0;       // 0=close, 1=open, 2=high, 3=low, 4=median((h+l/2)), 5=typical((h+l+c)/3), 6=weighted((h+l+c+c)/4)
extern double BreakOutLevel=35;         // Start trade after breakout is reached
extern bool UseTimeLimit=true;
extern int StartHour =7;                // Start trades after time
extern int StopHour=16;                 // Stop trading after time
extern bool UseFridayCloseAll=false;
extern int FridayCloseHour=20;
//----
int SignalBar=1;                       // 1 for prior, 0 for current
double Margincutoff=800;               // Expert will stop trading if equity level decreases to that level.
int Slippage=10;                       // Possible fix for not getting filled or closed    
int    MagicNumber;                    // Magic number of the trades. must be unique to identify
string   setup;                        // identifies the expert
bool YesStop;
double lotMM;
int TradesInThisSymbol;
double LongTradeRate=0.0;
double ShortTradeRate=0.0;
bool Converted=true;
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
   setup="BreakOut15 " + Symbol() + "_" + func_TimeFrame_Val2String(func_TimeFrame_Const2Val(Period()));
   MagicNumber=3000 + func_Symbol2Val(Symbol())*100 + func_TimeFrame_Const2Val(Period());
//---- 
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
   return(0);
  }
//+------------------------------------------------------------------------+
//| LSMA - Least Squares Moving Average function calculation               |
//| LSMA_In_Color Indicator plots the end of the linear regression line    |
//| Modified to use any timeframe                                          |
//+------------------------------------------------------------------------+
double LSMA(int Rperiod,int prMode, int TimeFrame, int mshift)
  {
   int i;
   double sum, price;
   int length;
   double lengthvar;
   double tmp;
   double wt;
   //
   length=Rperiod;
   //
   sum=0;
   for(i=length; i>=1 ;i--)
     {
      lengthvar=length + 1;
      lengthvar/=3;
      tmp=0;
      switch(prMode)
        {
         case 0: price=iClose(NULL,TimeFrame,length-i+mshift);break;
         case 1: price=iOpen(NULL,TimeFrame,length-i+mshift);break;
         case 2: price=iHigh(NULL,TimeFrame,length-i+mshift);break;
         case 3: price=iLow(NULL,TimeFrame,length-i+mshift);break;
         case 4: price=(iHigh(NULL,TimeFrame,length-i+mshift) + iLow(NULL,TimeFrame,length-i+mshift))/2;break;
         case 5: price=(iHigh(NULL,TimeFrame,length-i+mshift) + iLow(NULL,TimeFrame,length-i+mshift) + iClose(NULL,TimeFrame,length-i+mshift))/3;break;
         case 6: price=(iHigh(NULL,TimeFrame,length-i+mshift) + iLow(NULL,TimeFrame,length-i+mshift) + iClose(NULL,TimeFrame,length-i+mshift) + iClose(NULL,TimeFrame,length-i+mshift))/4;break;
        }
      tmp =(i - lengthvar)*price;
      sum+=tmp;
     }
   wt=sum*6/(length*(length+1));
//----
   return(wt);
  }
//+------------------------------------------------------------------+
//| CheckExitCondition                                               |
//| Check if LSMAs cross down to exit BUY or up to exit SELL         |
//+------------------------------------------------------------------+
bool CheckExitCondition(string TradeType)
  {
   bool YesClose;
   double fMA, sMA;
   //
   YesClose=false;
   //
   if (UseFridayCloseAll && DayOfWeek()==5 && Hour()>=FridayCloseHour) return(true);
   if (FastMA_Mode==4)
     {
      fMA=LSMA(FastMA_Period,FastMA_AppliedPrice,SignalTimeFrame,SignalBar);
     }
   else
     {
      fMA=iMA(NULL, SignalTimeFrame, FastMA_Period, FastMA_Shift, FastMA_Mode, FastMA_AppliedPrice, SignalBar);
     }
   if (SlowMA_Mode==4)
     {
      sMA=LSMA(SlowMA_Period,SlowMA_AppliedPrice,SignalTimeFrame,SignalBar);
     }
   else
     {
      sMA=iMA(NULL, SignalTimeFrame, SlowMA_Period, SlowMA_Shift, SlowMA_Mode, SlowMA_AppliedPrice, SignalBar);
     }
   // Check for cross down
   if (TradeType=="BUY" && fMA < sMA)YesClose=true;
   // Check for cross up
   if (TradeType=="SELL" && fMA > sMA) YesClose=true;
//----
   return(YesClose);
  }
//+------------------------------------------------------------------+
//| CheckEntryCondition                                              |
//| Check if LSMAs cross up for BUY or down for SELL                 |
//+------------------------------------------------------------------+
bool CheckEntryCondition(string TradeType)
  {
   bool YesTrade;
   double fMA, sMA;
   //
   YesTrade=false;
   if (FastMA_Mode==4)
     {
      fMA=LSMA(FastMA_Period,FastMA_AppliedPrice,SignalTimeFrame,SignalBar);
     }
   else
     {
      fMA=iMA(NULL, SignalTimeFrame, FastMA_Period, FastMA_Shift, FastMA_Mode, FastMA_AppliedPrice, SignalBar);
     }
   if (SlowMA_Mode==4)
     {
      sMA=LSMA(SlowMA_Period,SlowMA_AppliedPrice,SignalTimeFrame,SignalBar);
     }
   else
     {
      sMA=iMA(NULL, SignalTimeFrame, SlowMA_Period, SlowMA_Shift, SlowMA_Mode, SlowMA_AppliedPrice, SignalBar);
     }
   // Check for cross up
   if (TradeType=="BUY" && fMA > sMA)  YesTrade=true;
   // Check for cross down
   if (TradeType=="SELL" && fMA < sMA)YesTrade=true;
//----
   return(YesTrade);
  }
//+------------------------------------------------------------------+
//| script program start function                                    |
//+------------------------------------------------------------------+
int start()
  {
//---- 
   // Check for valid inputs
   if (Period()!=15)
     {
      Alert("15 Minute Chart Only.");
      return(0);
     }
   // Check if any pending Orders 
   Converted=true;
   if (LongTradeRate > 0.1) Converted=HandlePendingBuyOrder();
   if (ShortTradeRate > 0.1) Converted=HandlePendingSellOrder();
   if (!Converted) return(0);
   // Check if any open positions
   HandleOpenPositions();
   if (UseTimeLimit)
     {
      // trading from 7:00 to 13:00 GMT
      // trading from Start1 to Start2
      YesStop=true;
      if (Hour()>=StartHour && Hour() < StopHour) YesStop=false;
      //      Comment ("Trading has been stopped as requested - wrong time of day");
      if (YesStop) return(0);
     }
   TradesInThisSymbol=openPositions();
   //+------------------------------------------------------------------+
   //| Check if OK to make new trades                                   |
   //+------------------------------------------------------------------+
     if(AccountFreeMargin() < Margincutoff) 
     {
     return(0);
     }
   // Only allow 1 trade per Symbol
     if(TradesInThisSymbol > 0) 
     {
     return(0);
     }
   lotMM=GetLots();
   if(CheckEntryCondition("BUY") )
     {
      LongTradeRate=Ask + BreakOutLevel*Point;
      ShortTradeRate=0.0;
      return(0);
     }
   if (CheckEntryCondition("SELL"))
     {
      ShortTradeRate=Bid - BreakOutLevel * Point;
      LongTradeRate=0.0;
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Open Buy                                                         |
//| Open a new trade using Buy                                       |
//| If Stop Loss or TakeProfit are used the values are calculated    |
//| for each trade                                                   |
//+------------------------------------------------------------------+
void OpenBuyOrder()
  {
   int err,ticket;
   double myStopLoss=0, myTakeProfit=0;
   //
   myStopLoss=0;
   if(StopLoss > 0)myStopLoss=Ask - StopLoss * Point ;
   myTakeProfit=0;
   if (TakeProfit>0) myTakeProfit=Ask + TakeProfit * Point;
   ticket=OrderSend(Symbol(),OP_BUY,lotMM,Ask,Slippage,myStopLoss,myTakeProfit,setup,MagicNumber,0,Green);
   if(ticket<=0)
     {
      err=GetLastError();
      Print("Error opening BUY order [" + setup + "]: (" + err + ") " + ErrorDescription(err));
     }
  }
//+------------------------------------------------------------------+
//| Open Sell                                                        |
//| Open a new trade using Sell                                      |
//| If Stop Loss or TakeProfit are used the values are calculated    |
//| for each trade                                                   |
//+------------------------------------------------------------------+
void OpenSellOrder()
  {
   int err, ticket;
   double myStopLoss=0, myTakeProfit=0;
   //
   myStopLoss=0;
   if(StopLoss > 0)myStopLoss=Bid + StopLoss * Point ;
   myTakeProfit=0;
   if (TakeProfit > 0) myTakeProfit=Bid - TakeProfit * Point;
   ticket=OrderSend(Symbol(),OP_SELL,lotMM,ShortTradeRate,Slippage,myStopLoss,myTakeProfit,setup,MagicNumber,0,Red);
   if(ticket<=0)
     {
      err=GetLastError();
      Print("Error opening Sell order [" + setup + "]: (" + err + ") " + ErrorDescription(err));
     }
  }
//+------------------------------------------------------------------------+
//| counts the number of open positions                                    |
//+------------------------------------------------------------------------+
int openPositions(  )
  {  int op =0;
   for(int i=OrdersTotal()-1;i>=0;i--)                                // scan all orders and positions...
     {
      OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
      if (OrderMagicNumber()!=MagicNumber) continue;
      if(OrderSymbol()==Symbol() )
        {
         if(OrderType()==OP_BUY)op++;
         if(OrderType()==OP_SELL)op++;
        }
     }
   return(op);
  }
//+------------------------------------------------------------------+
//| Handle pending Buy order                                         |
//+------------------------------------------------------------------+
int HandlePendingBuyOrder()
  {
   // Check if still a valid breakout
   if (LongTradeRate > 0.1)
     {
      if(CheckExitCondition("BUY")) LongTradeRate=0.0;
      if(Hour() >=StopHour) LongTradeRate=0.0;
     }

   if (LongTradeRate > 0.1 && Ask>=LongTradeRate)
     {
      OpenBuyOrder();
      LongTradeRate=0.0;
      return(true);
     }
   return(false);
  }
//+------------------------------------------------------------------+
//| Handle pending Sell order                                        |
//+------------------------------------------------------------------+
int HandlePendingSellOrder()
  {
   // Check if still a valid breakout
   if (ShortTradeRate > 0.1)
     {
      if(CheckExitCondition("SELL")) ShortTradeRate=0.0;
      if(Hour() >=StopHour) ShortTradeRate=0.0;
     }
   if (ShortTradeRate > 0.1 && Bid<=ShortTradeRate)
     {
      OpenSellOrder();
      ShortTradeRate=0.0;
      return(true);
     }
   return(false);
  }
//+------------------------------------------------------------------+
//|  Close Open Position Controls                                    |
//|  Try to close position 3 times                                   |
//+------------------------------------------------------------------+
void CloseOrder(int ticket,double numLots,double close_price)
  {
   int CloseCnt, err;
   // try to close 3 Times
   CloseCnt=0;
   while(CloseCnt < 3)
     {
      if (OrderClose(ticket,numLots,close_price,Slippage,Violet))
        {
         CloseCnt=3;
        }
      else
        {
         err=GetLastError();
         Print(CloseCnt," Error closing order : (", err , ") " + ErrorDescription(err));
         if (err > 0) CloseCnt++;
        }
     }
  }
//+------------------------------------------------------------------+
//|  Modify Open Position Controls                                   |
//|  Try to modify position 3 times                                  |
//+------------------------------------------------------------------+
void ModifyOrder(int ord_ticket,double op, double price,double tp)
  {
   int CloseCnt, err;
   //
   CloseCnt=0;
   while(CloseCnt < 3)
     {
      if (OrderModify(ord_ticket,op,price,tp,0,Aqua))
        {
         CloseCnt=3;
        }
      else
        {
         err=GetLastError();
         Print(CloseCnt," Error modifying order : (", err , ") " + ErrorDescription(err));
         if (err>0) CloseCnt++;
        }
     }
  }
//+------------------------------------------------------------------+
//| HandleTrailingStop                                               |
//| Type 1 moves the stoploss without delay.                         |
//| Type 2 waits for price to move the amount of the trailStop       |
//| before moving stop loss then moves like type 1                   |
//| Type 3 uses up to 3 levels for trailing stop                     |
//|      Level 1 Move stop to 1st level                              |
//|      Level 2 Move stop to 2nd level                              |
//|      Level 3 Trail like type 1 by fixed amount other than 1      |
//| Possible future types                                            |
//| Type 4 uses 2 for 1, every 2 pip move moves stop 1 pip           |
//| Type 5 uses 3 for 1, every 3 pip move moves stop 1 pip           |
//+------------------------------------------------------------------+
int HandleTrailingStop(string type, int ticket, double op, double os, double tp)
  {
   double pt, TS=0;
   double bos,bop,opa,osa;
   //
   if (type=="BUY")
     {
      switch(TrailingStopType)
        {
         case 1: pt=Point*StopLoss;
            if(Bid-os > pt) ModifyOrder(ticket,op,Bid-pt,tp);
            break;
         case 2: pt=Point*TrailingStop;
            if(Bid-op > pt && os < Bid - pt) ModifyOrder(ticket,op,Bid - pt,tp);
            break;
         case 3: if (Bid - op > TRStopLevel_1 * Point)
              {
               TS=op + TRStopLevel_1*Point - TrailingStop1 * Point;
               if (os < TS)
                 {
                  ModifyOrder(ticket,op,TS,tp);
                 }
              }
            if (Bid - op > TRStopLevel_2 * Point)
              {
               TS=op + TRStopLevel_2*Point - TrailingStop2 * Point;
               if (os < TS)
                 {
                  ModifyOrder(ticket,op,TS,tp);
                 }
              }
            if (Bid - op > TRStopLevel_3 * Point)
              {
               //                   TS = op + TRStopLevel_3 * Point - TrailingStop3*Point;
               TS=Bid  - TrailingStop3*Point;
               if (os < TS)
                 {
                  ModifyOrder(ticket,op,TS,tp);
                 }
              }
            break;
        }
      return(0);
     }
   if (type== "SELL")
     {
      switch(TrailingStopType)
        {
         case 1: pt=Point*StopLoss;
            if(os - Ask > pt) ModifyOrder(ticket,op,Ask+pt,tp);
            break;
         case 2: pt=Point*TrailingStop;
            if(op - Ask > pt && os > Ask+pt) ModifyOrder(ticket,op,Ask+pt,tp);
            break;
         case 3: if (op - Ask > TRStopLevel_1 * Point)
              {
               TS=op - TRStopLevel_1 * Point + TrailingStop1 * Point;
               if (os > TS)
                 {
                  ModifyOrder(ticket,op,TS,tp);
                 }
              }
            if (op - Ask > TRStopLevel_2 * Point)
              {
               TS=op - TRStopLevel_2 * Point + TrailingStop2 * Point;
               if (os > TS)
                 {
                  ModifyOrder(ticket,op,TS,tp);
                 }
              }
            if (op - Ask > TRStopLevel_3 * Point)
              {
               //                  TS = op - TRStopLevel_3 * Point + TrailingStop3 * Point;               
               TS=Ask + TrailingStop3 * Point;
               if (os > TS)
                 {
                  ModifyOrder(ticket,op,TS,tp);
                 }
              }
            break;
        }
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Handle Open Positions                                            |
//| Check if any open positions need to be closed or modified        |
//+------------------------------------------------------------------+
int HandleOpenPositions()
  {
   int cnt;
   bool YesClose;
   double pt;
//----
   for(cnt=OrdersTotal()-1;cnt>=0;cnt--)
     {
      OrderSelect (cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderSymbol()!=Symbol()) continue;
      if(OrderMagicNumber()!=MagicNumber)  continue;
      if(OrderType()==OP_BUY)
        {
         if (CheckExitCondition("BUY"))
           {
            CloseOrder(OrderTicket(),OrderLots(),Bid);
           }
         else
           {
            if (UseTrailingStop)
              {
               HandleTrailingStop("BUY",OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
              }
           }
        }
      if(OrderType()==OP_SELL)
        {
         if (CheckExitCondition("SELL"))
           {
            CloseOrder(OrderTicket(),OrderLots(),Ask);
           }
         else
           {
            if(UseTrailingStop)
              {
               HandleTrailingStop("SELL",OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit());
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//| Get number of lots for this trade                                |
//+------------------------------------------------------------------+
double GetLots()
  {
   double lot;
//----
   lot=Lots;
   if(MoneyManagement)
     {
      lot=LotsOptimized();
     }
   if (lot>=1.0) lot=MathFloor(lot); else lot=1.0;
   return(lot);
  }
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double LotsOptimized()
  {
   double lot=Lots;
//---- select lot size
   lot=NormalizeDouble(MathFloor(AccountFreeMargin()*TradeSizePercent/10000)/10,1);
   // Check if mini or standard Account
   if (lot < 1.0) lot=1.0;
   if (lot > MaxLots) lot=MaxLots;
//----
   return(lot);
  }
//+------------------------------------------------------------------+
//| Time frame interval appropriation  function                      |
//+------------------------------------------------------------------+
  int func_TimeFrame_Const2Val(int Constant)
  {
     switch(Constant) 
     {
         case 1:  // M1
            return(1);
         case 5:  // M5
            return(2);
         case 15:
            return(3);
         case 30:
            return(4);
         case 60:
            return(5);
         case 240:
            return(6);
         case 1440:
            return(7);
         case 10080:
            return(8);
         case 43200:
            return(9);
        }
     }
         //+------------------------------------------------------------------+
         //| Time frame string appropriation  function                        |
         //+------------------------------------------------------------------+
           string func_TimeFrame_Val2String(int Value)
           {
              switch(Value) 
              {
                  case 1:  // M1
                     return("PERIOD_M1");
                  case 2:  // M1
                     return("PERIOD_M5");
                  case 3:
                     return("PERIOD_M15");
                  case 4:
                     return("PERIOD_M30");
                  case 5:
                     return("PERIOD_H1");
                  case 6:
                     return("PERIOD_H4");
                  case 7:
                     return("PERIOD_D1");
                  case 8:
                     return("PERIOD_W1");
                  case 9:
                     return("PERIOD_MN1");
                  default:
                     return("undefined " + Value);
                 }
              }
                  //+------------------------------------------------------------------+
                  //|                                                                  |
                  //+------------------------------------------------------------------+
                    int func_Symbol2Val(string symbol) 
                    {
                     string mySymbol=StringSubstr(symbol,0,6);
                     if(mySymbol=="AUDCAD") return(1);
                     if(mySymbol=="AUDJPY") return(2);
                     if(mySymbol=="AUDNZD") return(3);
                     if(mySymbol=="AUDUSD") return(4);
                     if(mySymbol=="CHFJPY") return(5);
                     if(mySymbol=="EURAUD") return(6);
                     if(mySymbol=="EURCAD") return(7);
                     if(mySymbol=="EURCHF") return(8);
                     if(mySymbol=="EURGBP") return(9);
                     if(mySymbol=="EURJPY") return(10);
                     if(mySymbol=="EURUSD") return(11);
                     if(mySymbol=="GBPCHF") return(12);
                     if(mySymbol=="GBPJPY") return(13);
                     if(mySymbol=="GBPUSD") return(14);
                     if(mySymbol=="NZDUSD") return(15);
                     if(mySymbol=="USDCAD") return(16);
                     if(mySymbol=="USDCHF") return(17);
                     if(mySymbol=="USDJPY") return(18);
                     return(19);
                    }
                  //+------------------------------------------------------------------+
                  //| return error description                                         |
                  //+------------------------------------------------------------------+
                  string ErrorDescription(int error_code)
                    {
                     string error_string;
                  //----
                     switch(error_code)
                       {
                        //---- codes returned from trade server
                        case 0:
                        case 1:   error_string="no error";                                                  break;
                        case 2:   error_string="common error";                                              break;
                        case 3:   error_string="invalid trade parameters";                                  break;
                        case 4:   error_string="trade server is busy";                                      break;
                        case 5:   error_string="old version of the client terminal";                        break;
                        case 6:   error_string="no connection with trade server";                           break;
                        case 7:   error_string="not enough rights";                                         break;
                        case 8:   error_string="too frequent requests";                                     break;
                        case 9:   error_string="malfunctional trade operation";                             break;
                        case 64:  error_string="account disabled";                                          break;
                        case 65:  error_string="invalid account";                                           break;
                        case 128: error_string="trade timeout";                                             break;
                        case 129: error_string="invalid price";                                             break;
                        case 130: error_string="invalid stops";                                             break;
                        case 131: error_string="invalid trade volume";                                      break;
                        case 132: error_string="market is closed";                                          break;
                        case 133: error_string="trade is disabled";                                         break;
                        case 134: error_string="not enough money";                                          break;
                        case 135: error_string="price changed";                                             break;
                        case 136: error_string="off quotes";                                                break;
                        case 137: error_string="broker is busy";                                            break;
                        case 138: error_string="requote";                                                   break;
                        case 139: error_string="order is locked";                                           break;
                        case 140: error_string="long positions only allowed";                               break;
                        case 141: error_string="too many requests";                                         break;
                        case 145: error_string="modification denied because order too close to market";     break;
                        case 146: error_string="trade context is busy";                                     break;
                        //---- mql4 errors
                        case 4000: error_string="no error";                                                 break;
                        case 4001: error_string="wrong function pointer";                                   break;
                        case 4002: error_string="array index is out of range";                              break;
                        case 4003: error_string="no memory for function call stack";                        break;
                        case 4004: error_string="recursive stack overflow";                                 break;
                        case 4005: error_string="not enough stack for parameter";                           break;
                        case 4006: error_string="no memory for parameter string";                           break;
                        case 4007: error_string="no memory for temp string";                                break;
                        case 4008: error_string="not initialized string";                                   break;
                        case 4009: error_string="not initialized string in array";                          break;
                        case 4010: error_string="no memory for array\' string";                             break;
                        case 4011: error_string="too long string";                                          break;
                        case 4012: error_string="remainder from zero divide";                               break;
                        case 4013: error_string="zero divide";                                              break;
                        case 4014: error_string="unknown command";                                          break;
                        case 4015: error_string="wrong jump (never generated error)";                       break;
                        case 4016: error_string="not initialized array";                                    break;
                        case 4017: error_string="dll calls are not allowed";                                break;
                        case 4018: error_string="cannot load library";                                      break;
                        case 4019: error_string="cannot call function";                                     break;
                        case 4020: error_string="expert function calls are not allowed";                    break;
                        case 4021: error_string="not enough memory for temp string returned from function"; break;
                        case 4022: error_string="system is busy (never generated error)";                   break;
                        case 4050: error_string="invalid function parameters count";                        break;
                        case 4051: error_string="invalid function parameter value";                         break;
                        case 4052: error_string="string function internal error";                           break;
                        case 4053: error_string="some array error";                                         break;
                        case 4054: error_string="incorrect series array using";                             break;
                        case 4055: error_string="custom indicator error";                                   break;
                        case 4056: error_string="arrays are incompatible";                                  break;
                        case 4057: error_string="global variables processing error";                        break;
                        case 4058: error_string="global variable not found";                                break;
                        case 4059: error_string="function is not allowed in testing mode";                  break;
                        case 4060: error_string="function is not confirmed";                                break;
                        case 4061: error_string="send mail error";                                          break;
                        case 4062: error_string="string parameter expected";                                break;
                        case 4063: error_string="integer parameter expected";                               break;
                        case 4064: error_string="double parameter expected";                                break;
                        case 4065: error_string="array as parameter expected";                              break;
                        case 4066: error_string="requested history data in update state";                   break;
                        case 4099: error_string="end of file";                                              break;
                        case 4100: error_string="some file error";                                          break;
                        case 4101: error_string="wrong file name";                                          break;
                        case 4102: error_string="too many opened files";                                    break;
                        case 4103: error_string="cannot open file";                                         break;
                        case 4104: error_string="incompatible access to a file";                            break;
                        case 4105: error_string="no order selected";                                        break;
                        case 4106: error_string="unknown symbol";                                           break;
                        case 4107: error_string="invalid price parameter for trade function";               break;
                        case 4108: error_string="invalid ticket";                                           break;
                        case 4109: error_string="trade is not allowed";                                     break;
                        case 4110: error_string="longs are not allowed";                                    break;
                        case 4111: error_string="shorts are not allowed";                                   break;
                        case 4200: error_string="object is already exist";                                  break;
                        case 4201: error_string="unknown object property";                                  break;
                        case 4202: error_string="object is not exist";                                      break;
                        case 4203: error_string="unknown object type";                                      break;
                        case 4204: error_string="no object name";                                           break;
                        case 4205: error_string="object coordinates error";                                 break;
                        case 4206: error_string="no specified subwindow";                                   break;
                        default:   error_string="unknown error";
                       }
                     //----
                     return(error_string);
                    }
//+------------------------------------------------------------------+



Sample





Analysis



Market Information Used:

Series array that contains close prices for each bar
Series array that contains open prices of each bar
Series array that contains the highest prices of each bar
Series array that contains the lowest prices of each bar


Indicator Curves created:


Indicators Used:

Moving average indicator


Custom Indicators Used:

Order Management characteristics:
It automatically opens orders when conditions are reached
Checks for the total of open orders
It Closes Orders by itself
It can change open orders parameters, due to possible stepping strategy

Other Features:

It issuies visual alerts to the screen

BackTest : EURUSD on H1

From 2009-08-01 to 2009-10-01 Profit Factor:0.00 Total Net Profit:0.00

BackTest : EURUSD on H1

From 2009-11-01 to 2009-11-30 Profit Factor:0.00 Total Net Profit:0.00

BackTest : EURUSD on H1

From 2009-12-01 to 2010-01-17 Profit Factor:0.00 Total Net Profit:0.00

BackTest : EURUSD on H1

From 2010-03-01 to 2010-03-27 Profit Factor:0.00 Total Net Profit:0.00

BackTest : EURUSD on H1

From 2010-04-01 to 2010-04-30 Profit Factor:0.00 Total Net Profit:0.00

BackTest : EURUSD on H1

From 2010-05-01 to 2010-05-31 Profit Factor:0.00 Total Net Profit:0.00

BackTest : EURUSD on H1

From 2010-06-01 to 2010-06-30 Profit Factor:0.00 Total Net Profit:0.00

BackTest : GBPUSD on H1

From 2010-01-01 to 2010-02-27 Profit Factor:0.00 Total Net Profit:0.00

BackTest : USDCAD on H1

From 2009-01-01 to 2010-01-01 Profit Factor:0.00 Total Net Profit:0.00

BackTest : USDCAD on H1

From 2009-12-01 to 2010-01-01 Profit Factor:0.00 Total Net Profit:0.00

BackTest : USDJPY on H1

From 2009-11-01 to 2009-11-30 Profit Factor:0.00 Total Net Profit:0.00

Request Backtest for Breakout15_v1


From : (yyyy/mm/dd) To: (yyyy/mm/dd)

Pair: Period: