SimpleDailyRangeBreakExpert_v1[1].22

Author: Copyright � 2006, TrendLaboratory
Profit factor:
0.95
Orders Execution
Checks for the total of open ordersIt Closes Orders by itself It can change open orders parameters, due to possible stepping strategyIt automatically opens orders when conditions are reached
5 Views
0 Downloads
0 Favorites
SimpleDailyRangeBreakExpert_v1[1].22
//+------------------------------------------------------------------+
//|                            SimpleDailyRangeBreakExpert_v1.22.mq4 |
//|                                Copyright © 2006, TrendLaboratory |
//|            http://finance.groups.yahoo.com/group/TrendLaboratory |
//|                                   E-mail: igorad2003@yahoo.co.uk |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, TrendLaboratory"
#property link      "http://finance.groups.yahoo.com/group/TrendLaboratory"

#include <stdlib.mqh>
//#include <Tracert.mqh>

//---- input parameters
extern string     Expert_Name = "---- SimpleDailyRangeBreakExpert_v1.22 ----";

extern int        Magic          = 12345;
extern int        Slippage       =     6;

extern bool       Trace = false;           // Trace Switch

extern string     Main_Parameters = " Trade Volume & Trade Method";
extern double     Lots           =   0.3;
extern double     TrailingStop   =     0;  // Trailing Stop Switch   
extern bool       InitialStop    =  true;  // Initial Stop Switch
extern int        TimeZone       =     0;   

extern string     Data = " Input Data ";
extern double     BuyPercent     =    70;  // Percent from Daily Range for BUY 	
extern double     SellPercent    =    70;  // Percent from Daily Range for SELL
extern double     StopPercent    =    50;  // Percent from Daily Range for StopLoss
extern int        TradePeriod    =     5;  // Max days in trade 
extern double     BreakEven      =     0;  // BreakEven Level in pips
extern double     BreakEvenGap   =     0;  // Pips when BreakEven will be reached

extern string     Trade   =  " Trade Days of Week";
extern int        Monday         =     1;  // Day of the Week for Trade
extern int        Tuesday        =     1;
extern int        Wednesday      =     1;
extern int        Thursday       =     1;
extern int        Friday         =     1;

extern string     MM_Parameters = " MoneyManagement by L.Williams ";
extern bool       MM             = false;  // ÌÌ Switch
extern double     MMRisk         =  0.15;  // Risk Factor
extern double     LossMax        =  1000;  // Maximum Loss by 1 Lot


int      i,cnt=0, ticket, mode=0, digit=0, wenum=0,OrderOpenDay, DaysInTrade, Kz;
double   high=0,low=0, close=0, open=0, range=0, spread=0, Profit=0;
double   smin=0, smax=0, BuyStop=0, SellStop=0, Lotsi=0, rates_h1[][6];
bool     BuyInTrade=false, SellInTrade=false;
datetime StartTime, prevwe=0, Today, PrevDay;
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
//---- 

//----
   return(0);
  }
// ---- Money Management
double MoneyManagement ( bool flag, double Lots, double risk, double maxloss)
{
   double Lotsi=Lots;
	    
   if ( flag ) Lotsi=NormalizeDouble(Lots*AccountFreeMargin()*risk/maxloss,1);   
     
   if (Lotsi<0.1) Lotsi=0.1;  
   return(Lotsi);
}   

// Closing of Pending Orders      
void PendOrdDel()
{
   int total=OrdersTotal();
   for (int cnt=total-1;cnt>=0;cnt--)
   { 
   OrderSelect(cnt, SELECT_BY_POS,MODE_TRADES);   
      
      if ( OrderSymbol()==Symbol() && OrderMagicNumber()==Magic  )     
      {
      int mode=OrderType();
        
      bool result = false;
         switch(mode)
         {
         case OP_BUYSTOP   :  {
                              result = OrderDelete( OrderTicket() );
                                 if(!result)
                                 {
                                 Print("BUYSTOP: OrderDelete failed with error #",GetLastError());
                                 return(0);
                                 }
                              break;
                              }
          
         case OP_SELLSTOP  :  {
                              result = OrderDelete( OrderTicket() );  
                                 if(!result)
                                 {
                                 Print("SELLSTOP: OrderDelete failed with error #",GetLastError());
                                 return(0);
                                 }
                              break;
                              }
                                
         }
      }
   } 
}    

// 

void CloseOrdbyTime()
{
   int total=OrdersTotal();
    
   for (cnt=0;cnt<total;cnt++)
   { 
   OrderSelect(cnt, SELECT_BY_POS);   
   mode=OrderType();
      if ( mode <= OP_SELL && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
      { 
         if (DaysInTrade >= TradePeriod || OrderProfit()>0)
         {
            if (mode==OP_BUY )
			   OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,Yellow);
			   if (mode==OP_SELL)
			   OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,White);
         }
      }
   }
}       
 
// ---- 
void TrailStop()
{
   for (cnt=0;cnt<OrdersTotal();cnt++)
   { 
   OrderSelect(cnt, SELECT_BY_POS);   
   int mode=OrderType();    
      if ( OrderSymbol()==Symbol() && OrderMagicNumber()==Magic) 
      {
         if (mode==OP_BUY) 
         {
			BuyStop = Bid - TrailingStop*Point;
			   if( OrderOpenPrice() < BuyStop || OrderStopLoss() == 0 ) 
            {   
			      if ( BuyStop > OrderStopLoss() ) 
			      {
			      bool result = OrderModify(OrderTicket(),OrderOpenPrice(),
			                                NormalizeDouble(BuyStop, Digits),
			                                OrderTakeProfit(),0,LightGreen);
			         if( !result )
                  {
                  Print("BUY: OrderModify failed with error #",GetLastError());
                  }
			      return(0);
               }            
            }
         }   
// - SELL Orders          
         if (mode==OP_SELL)
         {
         SellStop = Ask + Point * TrailingStop;   
            if( OrderOpenPrice() > SellStop) 
            {
               if( OrderStopLoss() > SellStop || OrderStopLoss() == 0 ) 
               {
               OrderModify(OrderTicket(), OrderOpenPrice(),
                           NormalizeDouble(SellStop, Digits),
			                  OrderTakeProfit(),0,DarkOrange);
                  if( !result )
                  {
                  Print("SELL: OrderModify failed with error #",GetLastError());
                  }
               return(0);
               }   
   			}	    
         }
      }
   }     
}

void SellOrdOpen()
{		     
   double SellPrice=open - range*SellPercent/100.0 - spread;
	
	if (InitialStop) SellStop=SellPrice + StopPercent*range/100.0; else SellStop=0;
   Profit=0;
	       
	ticket = OrderSend(Symbol(),OP_SELLSTOP,Lotsi,
	                   NormalizeDouble(SellPrice,digit),
	                   Slippage,
	                   NormalizeDouble(SellStop,digit),
	                   Profit,"SELL",Magic,0,Red);
    

   OrderOpenDay  = DayOfWeek();   
   SellInTrade=false;            
       
   if(ticket<0)
   {
   Print("Sell: OrderSend failed with error #",GetLastError());
   return(0);
   }
}

void BuyOrdOpen()
{		     
   double BuyPrice =open + range*BuyPercent/100.0  + spread;
	if (InitialStop) BuyStop = BuyPrice - StopPercent*range/100.0; else BuyStop=0;
   Profit=0;
		 
	ticket = OrderSend(Symbol(),OP_BUYSTOP ,Lotsi,
	                   NormalizeDouble(BuyPrice ,digit),
	                   Slippage,
	                   NormalizeDouble(BuyStop ,digit),
	                   Profit,"BUY",Magic,0,Blue);
           
   OrderOpenDay  = DayOfWeek();
   BuyInTrade=false;            
       
   if(ticket<0)
   {
   Print("Buy: OrderSend failed with error #",GetLastError());
   return(0);
   }
}      

void ExtraOrdDel()
{
   int total = OrdersTotal();
   for (cnt=0;cnt<total;cnt++)
   { 
   OrderSelect(cnt, SELECT_BY_POS);   
   mode=OrderType();
      if ( OrderSymbol()==Symbol() && OrderMagicNumber()==Magic )     
      {
      if (mode==OP_BUY  && !BuyInTrade ) BuyInTrade =true;
      if (mode==OP_SELL && !SellInTrade) SellInTrade=true;
            
         if (mode == OP_SELLSTOP && BuyInTrade )
         { 
         bool result = OrderDelete(OrderTicket()); 
         SellInTrade=false; 
            if(!result)
            {
            Print("ExtraSELL: OrderDelete failed with error #",GetLastError());
            return(0);
            } 
         }
         if (mode == OP_BUYSTOP && SellInTrade )
         { 
         result = OrderDelete(OrderTicket()); 
         BuyInTrade=false; 
            if(!result)
            {
            Print("ExtraBUY: OrderDelete failed with error #",GetLastError());
            return(0);
            }  
         }
      }
   }        
}

// ---- Scan Trades
int ScanTrades()
{   
   int total = OrdersTotal();
   int numords = 0;
      
   for(cnt=0; cnt<total; cnt++) 
   {        
   OrderSelect(cnt, SELECT_BY_POS);            
   if(OrderSymbol() == Symbol() && OrderType()>=OP_BUY && OrderMagicNumber() == Magic) 
   numords++;
   }
   return(numords);
}

datetime OrderOpenDate()
{
   int total = OrdersTotal();
   datetime date;
   for(cnt=0; cnt<total; cnt++) 
   {        
   OrderSelect(cnt, SELECT_BY_POS);            
   if(OrderSymbol() == Symbol() && OrderType()>=OP_BUY && OrderMagicNumber() == Magic) 
   date = StrToTime(TimeToStr(OrderOpenTime(),TIME_DATE));
   }
   return(date);
}  

void BreakEvenStop()
{        
   for (cnt=0;cnt<OrdersTotal();cnt++)
   { 
   OrderSelect(cnt, SELECT_BY_POS);   
   int mode=OrderType();    
      if ( OrderSymbol()==Symbol() && OrderMagicNumber()==Magic) 
      {
         if (mode==OP_BUY)
         {
			   if (Bid-OrderOpenPrice() > BreakEven*Point) 
			   {  
			   Kz = MathFloor((Bid-OrderOpenPrice())/(BreakEven*Point));   
			      if (Bid-OrderOpenPrice() > Kz*BreakEven*Point) 
			      {
			      BuyStop=OrderOpenPrice()+((Kz-1)*BreakEven+BreakEvenGap)*Point;
			      if ( OrderStopLoss() == 0 ) double StopLoss = OrderOpenPrice(); else StopLoss = OrderStopLoss();   
			         if (BuyStop > StopLoss )
			         {
			         OrderModify(OrderTicket(),OrderOpenPrice(),
			                     NormalizeDouble(BuyStop, digit),
			                     OrderTakeProfit(),0,LightBlue);
			            
			          return(0);
			         }
			      }
            }
         }               			         
               
         if (mode==OP_SELL)
         {
            if (OrderOpenPrice()-Ask > BreakEven*Point)
            {
            Kz = MathFloor((OrderOpenPrice()-Ask)/(BreakEven*Point)); 
               if (OrderOpenPrice()-Ask > Kz*BreakEven*Point) 
			      {
			      SellStop=OrderOpenPrice()-((Kz-1)*BreakEven+BreakEvenGap)*Point;
			      if ( OrderStopLoss() == 0 ) StopLoss = OrderOpenPrice(); else StopLoss = OrderStopLoss();   
			         if ( SellStop < StopLoss )
			         {
			         OrderModify(OrderTicket(),OrderOpenPrice(),
			                     NormalizeDouble(SellStop, digit),
			                     OrderTakeProfit(),0,Orange);
			            
			         return(0);
			         }
               }
		      }
         }
      }   
   } 
}	                    
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
{
   if(Bars < 1) {Print("Not enough bars for this strategy"); return(0);}
  
 //  if ( Trace ) SetTrace();
  
   string   TimeTrade = "00:00";
   StartTime  = StrToTime(TimeTrade) + TimeZone*3600;
  
   if(CurTime() >= StartTime && CurTime() <= StartTime+3600)
   {
      if ( OrderOpenDate() < StrToTime(TimeToStr( StartTime,TIME_DATE))) 
      { 
      if( ScanTrades()>0 && !BuyInTrade && !SellInTrade) PendOrdDel(); 
      Today = StrToTime(TimeToStr( StartTime,TIME_DATE));
      if (Today != PrevDay ) 
      { DaysInTrade = DaysInTrade+1; 
      //Print(" Days=",DaysInTrade,"Today=",TimeToStr(Today,TIME_DATE),"PrevDay=", TimeToStr(PrevDay,TIME_DATE)) ;
      PrevDay=Today;}
      
      if( TradePeriod > 0 )CloseOrdbyTime(); 
      }
      
      if(ScanTrades()<1)
      {
      
      spread= MarketInfo(Symbol(),MODE_SPREAD)*Point;
      digit  = MarketInfo(Symbol(),MODE_DIGITS);
      Lotsi = MoneyManagement ( MM, Lots, MMRisk, LossMax);
      if (TrailingStop > 0) InitialStop=true; 
   
      ArrayCopyRates(rates_h1, Symbol(), PERIOD_H1);
      open = rates_h1[0][1];
      high=0; low=10000000;
      for (i=24;i>=1;i--)
      {
      high = MathMax( high, rates_h1[i][3]);
      low  = MathMin( low , rates_h1[i][2]);      
      }   
       
      range =(high-low); 
      
          
   
      if ( Monday   == 1 ) if(DayOfWeek()==1){BuyOrdOpen(); SellOrdOpen();}
      if ( Tuesday  == 1 ) if(DayOfWeek()==2){BuyOrdOpen(); SellOrdOpen();}
      if ( Wednesday== 1 ) if(DayOfWeek()==3){BuyOrdOpen(); SellOrdOpen();} 
      if ( Thursday == 1 ) if(DayOfWeek()==4){BuyOrdOpen(); SellOrdOpen();} 
      if ( Friday   == 1 ) if(DayOfWeek()==5){BuyOrdOpen(); SellOrdOpen();}
      DaysInTrade = 0;
      }
      
    
   }
   ExtraOrdDel();
   if (BreakEven > 0) BreakEvenStop();
   if (TrailingStop > 0 ) TrailStop(); 
 return(0);
}//int start
//+------------------------------------------------------------------+





Profitability Reports

USD/JPY Jul 2025 - Sep 2025
1.11
Total Trades 27
Won Trades 12
Lost trades 15
Win Rate 44.44 %
Expected payoff 5.24
Gross Profit 1456.34
Gross Loss -1314.92
Total Net Profit 141.42
-100%
-50%
0%
50%
100%
USD/CHF Jul 2025 - Sep 2025
1.38
Total Trades 26
Won Trades 17
Lost trades 9
Win Rate 65.38 %
Expected payoff 13.19
Gross Profit 1255.40
Gross Loss -912.39
Total Net Profit 343.01
-100%
-50%
0%
50%
100%
USD/CAD Jul 2025 - Sep 2025
1.28
Total Trades 30
Won Trades 18
Lost trades 12
Win Rate 60.00 %
Expected payoff 5.51
Gross Profit 756.66
Gross Loss -591.37
Total Net Profit 165.29
-100%
-50%
0%
50%
100%
GBP/USD Jul 2025 - Sep 2025
1.05
Total Trades 31
Won Trades 19
Lost trades 12
Win Rate 61.29 %
Expected payoff 1.90
Gross Profit 1197.60
Gross Loss -1138.80
Total Net Profit 58.80
-100%
-50%
0%
50%
100%
GBP/AUD Jul 2025 - Sep 2025
0.85
Total Trades 29
Won Trades 14
Lost trades 15
Win Rate 48.28 %
Expected payoff -6.72
Gross Profit 1081.78
Gross Loss -1276.54
Total Net Profit -194.76
-100%
-50%
0%
50%
100%
EUR/USD Jul 2025 - Sep 2025
0.65
Total Trades 66
Won Trades 17
Lost trades 49
Win Rate 25.76 %
Expected payoff -18.17
Gross Profit 2266.50
Gross Loss -3465.60
Total Net Profit -1199.10
-100%
-50%
0%
50%
100%
AUD/USD Jul 2025 - Sep 2025
1.21
Total Trades 26
Won Trades 15
Lost trades 11
Win Rate 57.69 %
Expected payoff 5.07
Gross Profit 752.70
Gross Loss -621.00
Total Net Profit 131.70
-100%
-50%
0%
50%
100%
USD/JPY Jan 2025 - Jul 2025
0.93
Total Trades 63
Won Trades 30
Lost trades 33
Win Rate 47.62 %
Expected payoff -4.65
Gross Profit 3624.52
Gross Loss -3917.70
Total Net Profit -293.18
-100%
-50%
0%
50%
100%
USD/CHF Jan 2025 - Jul 2025
1.12
Total Trades 66
Won Trades 37
Lost trades 29
Win Rate 56.06 %
Expected payoff 5.77
Gross Profit 3598.51
Gross Loss -3217.38
Total Net Profit 381.13
-100%
-50%
0%
50%
100%
NZD/USD Jan 2025 - Jul 2025
0.69
Total Trades 66
Won Trades 34
Lost trades 32
Win Rate 51.52 %
Expected payoff -11.51
Gross Profit 1656.90
Gross Loss -2416.50
Total Net Profit -759.60
-100%
-50%
0%
50%
100%

Comments