Price Data Components
Orders Execution
Miscellaneous
4
Views
0
Downloads
0
Favorites
jMasterRSXv1D
//+------------------------------------------------------------------------------------------------------+
//| jMasterRSXv1.mq4 |
//| Jiri Balcar © 2009 |
//| jirimac@yahoo.com |
//| modifications © 2009 by Richard Ingraham |
//| ringraham44@charter.net |
//| GBPUSD/EURUSD |
//| ***NOTE: While these modifications were designed using GBPUSD |
//| the original trading logic was used on EURUSD with |
//| success. The modifications use almost the same trading logic (very slight mods) |
//| with enhanced functionalty for various brokers It will |
//| now work with 4 or 5 digit (fractional pip broker). The modifications |
//| also now have enhanced trade size and money mangement |
//| features and trailing/stoploss/+takeproit options. |
//| |
//| While the simplicity of the original coding was not able |
//| to be maintained with the added features, I believe you |
//| will see why they were needed. |
//| |
//| I recommend and have included the ability to turn off all of the added options during |
//| optimization. Just optimize the time period parameters and indicator parameters using |
//| the money management feature set real low (1 or 2%). Then try using the features to refine |
//| your results further. This EA is a real BARNSTORMER for profits if you have patience. |
//| In testing many EAs, I've noticed that the market has had a very fundamental change around |
//| Jan/Mar of 09. This EA functions real well with the 'new' market conditions, although I've |
//| tested it on prior years and got it working well then, too. I've not yet been able to get it|
//| to cross over that time period and maintain good functionality. You can achieve good results|
//| using this EA with settings that generate lots of trades, however the drawdown is quite high|
//| and it seems to work best with fewer trades (8-15 per month) on GBPUSD, but is very accurate|
//| at that rate. I use it on 1H GBPUSD chart. |
//| My backtesting is complete and forward testing is commencing but will (obviously) take time |
//| to generate meaningful results. Please post yours as well. |
//| |
//| You may use the Open Price Only feature in the tester as it only uses the open prices of |
//| each bar, which really helps the optimization time. You can easily exceed a profit factor |
//| of 3 with this EA with less than 40% drawdown as long as your willing to accept few trades. |
//| |
//| IMPORTANT NOTE!!! |
//| In Optimizing this EA it is VERY important to turn off the Trail/Takeprofit features and |
//| ONLY use a Pip Stoploss setting if desired to suit your comfort level. Otherwise the test |
//| results will reflect the natural support and resistance levels in the PAST market and not |
//| give a true reading of the indicators effectiveness for FUTURE results in the long term. |
//| |
//| Also please note the if you use any of the BAR features for Stop/TakeProfit/Trail the EA |
//| defaults to the PIP setting if the BAR selected is too close to the price being used for the|
//| feature (I used a 10 pip buffer). So when using these features set the Pip levels to 0 if |
//| you don't want that to effect the bar price selection. I use them in combo together AFTER |
//| getting the best indicator settings. |
//| |
//| Best Regards and wishes for success!! Richard Ingraham |
//+------------------------------------------------------------------------------------------------------+
extern string TRADE_COMM = "RSXv1_D";
extern int MAGICMA = 072609;// Multiple EAs can run on different charts simultaneously by changing this
// for each one
extern double Lots = 0.1; // Lots traded if MM is not enabled
extern double DecreaseFactor = 0; // will decrease trades in proportion to the success rate of the EA
extern int DF_Engage = 1; // Number of consecutive losses before Decrease Factor is engaged
extern bool UseMoneyManagement = true; //
extern double MaximumRisk = 0.01; // Will trade multiple times if the maximum lot size is exceeded by the
extern double Max_Lot_Size = 50; // % calculations up to the max_num_lots amount. This parameter is broker
extern double Max_Num_Lots = 500; // specific and must adhere to their policies. if unsure of maximums, ask
// broker, some restrict the maximum number of lots traded per instrument.
// The tester does NOT adhere to those policies and will differ from live
// trading results if these parameters are incorrect!!
// If unsure of Maximum Lot Size leave this parameter @ 0.
extern int LongPer = 15; // Utilizes RSX indicator data from these TWO timeframes
extern int ShortPer = 5; //
extern int LongRSX = 10; // Indicator timeframe parameters for the above time periods
extern int ShortRSX = 4; //
extern int LongParBuy = 25; // Trading logic: Will Buy if RSX (Long Time Period) is above the LongParBuy parameter and
extern int ShortParBuy = 25; // if the RSX (Short Time Period) is below the ShortParBuy parameter
extern int LongParSell = 75; // Will Sell if RSX (Long Time Period) is bleow the LongParSell parameter and
extern int ShortParSell = 75; // if the RSX (Short Time Period) is above the ShortParSell parameter
extern int LongTrendSpread = 4; // How many bars of the LongPer Trend before trading allowed MIN 2
// Linear Regression Channel is calculated on 4HR time period, then if the slope is greater than
// the LinRegTrade parameter trading will be allowed. Open trades will still be
// exited at the specified indicator regardless of this setting. This ONLY controls
// the opening of new orders.
extern int LinRegLen = 5; // Length of Linear Regression Channel for Trade Control
extern double LinRegTrade = 40; // Slope of Linear Regression Channel to allow trading (in pips)
extern bool TradeTrend = true; // Trading if Linear Regression Slope GREATER than LinRegTrade parameter ALWAYS SET AS TRUE
//extern bool TradeRange = false; // Trading if Linear Regression Slope LESS than LinRegTrade parameter (NOT USED)
extern string s2 = "__________________Take Profit Parameters";
extern string s2a = "..................Mode 0 = Profit by Pips Mode";
extern string s2b = "..................Mode 1 = Profit by Highest/Lowest of Range of Bars";
extern string s2c = "..................Mode 2 = Profit by High/Low of Bar x";
extern bool UseTakeProfit = false;
extern int TakeProfitMode = 0;
extern string s3 = "__________________Stop Loss Parameters";
extern string s31 = "..................Mode 0 = Stop by Pips Mode";
extern string s32 = "..................Mode 1 = Stop by Highest/Lowest of Range of Bars";
extern string s33 = "..................Mode 2 = Stop by High/Low of Bar x";
extern bool UseStopLoss = false;
extern int StopMode = 1;
extern string s4 = "__________________Trailing Stop Parameters";
extern string s41 = "..................Mode 0 = Trail by Pips Mode";
extern string s42 = "..................Mode 1 = Trail by Highest/Lowest of Range of Bars";
extern string s43 = "..................Mode 2 = Trail by High/Low of Bar x";
extern bool UseTrail = false;
extern int TrailMode = 1;
extern string s5 = "__________________Buy Order Parameters";
extern int TakeProfitPip_Buy = 150;
extern int TakeProfitBar_Buy = 0;
extern int StopPip_Buy = 0;
extern int StopBar_Buy = 7;
extern int TrailPip_Buy = 0;
extern int TrailBar_Buy = 7;
extern int TrailMin_Buy = 0;
extern string s6 = "__________________Sell Order Parameters";
extern int TakeProfitPip_Sell = 150;
extern int TakeProfitBar_Sell = 0;
extern int StopPip_Sell = 0;
extern int StopBar_Sell = 7;
extern int TrailPip_Sell = 0;
extern int TrailBar_Sell = 7;
extern int TrailMin_Sell = 0;
bool cBuy, cSell, cExitBuy, cExitSell, Buy, Sell;
int lastgotime, gotime,digits;
double point;
double LR_line[100],Sup_line[100], Res_line[100];
//+------------------------------------------------------------------+
//| Calculate open orders |
//+------------------------------------------------------------------+
int OpenOrders(string symbol)
{
int co=0;
int total = OrdersTotal();
for (int i=total-1; i >=0; i--)
{
OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
if (OrderMagicNumber()==MAGICMA && OrderSymbol()==Symbol() && (OrderType()==OP_BUY || OrderType()==OP_SELL))
{
co++;
}
}
return(co);
}
//+------------------------------------------------------------------+
//| Calculate optimal lot size |
//+------------------------------------------------------------------+
double LotsOptimized()
{
double lot=Lots, MarginReq, LotVel, MINLOT, MAXLOT;
int orders=HistoryTotal(); // history orders total
int losses=0; // number of losses orders without a break
//---- select lot size
if(UseMoneyManagement)
{
MarginReq = MarketInfo(Symbol(), MODE_MARGINREQUIRED);
if (MarginReq == 0.0)
return(0);
LotVel = GetFreeMargin()
* MaximumRisk / MarginReq;
lot=NormalizeDouble(LotVel,1);
}
//---- calcuulate number of losses orders without a break
if(DecreaseFactor>0)
{
for(int i=orders-1;i>=0;i--)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==false) { Print("Error in history!"); break; }
if(OrderSymbol()!=Symbol() || OrderType()>OP_SELL) continue;
//----
if(OrderProfit()>0) break;
if(OrderProfit()<0) losses++;
}
if(losses>DF_Engage) lot=NormalizeDouble(lot-(lot*losses/DecreaseFactor),1);
}
MINLOT = MarketInfo(Symbol(), MODE_MINLOT);
if (MINLOT < 0) return(0);
if (lot < MINLOT) lot = MINLOT;
if (lot > Max_Num_Lots) lot = Max_Num_Lots;
//---- return lot size
return(lot);
}
//+==================================================================+
//| GetFreeMargin() function |
//+==================================================================+
double GetFreeMargin()
{
//----+
switch(AccountFreeMarginMode())
{
case 0: return(AccountFreeMargin() + AccountProfit());
case 1: return(AccountFreeMargin());
case 2: if (AccountProfit() > 0)
return(AccountFreeMargin());
else
return(AccountFreeMargin() - AccountProfit());
case 3: if (AccountProfit() < 0)
return(AccountFreeMargin());
else
return(AccountFreeMargin() - AccountProfit());
}
//----+
}
//+------------------------------------------------------------------+
//| Check for open order conditions |
//+------------------------------------------------------------------+
void CheckForOpen(bool Buying, bool Selling)
{
int hstTotal=HistoryTotal(),BarNum,SLPips;
double CurBid,CurAsk, StopLevel, TakeProfitLevel,SLevel,TPLevel,TradeLots;
Buy=false;
Sell=false;
if(Max_Lot_Size<=0) Max_Lot_Size = MarketInfo(Symbol(),MODE_MAXLOT);
StopLevel = 0;
TakeProfitLevel = 0;
if(UseStopLoss)
{
if(StopMode == 0)
{
if(Buying) StopLevel = NormalizeDouble(Ask-(StopPip_Buy*point), digits);
if(Selling) StopLevel = NormalizeDouble(Bid+(StopPip_Sell*point), digits);
}
if(StopMode == 1)
{
if(Buying)
{
SLevel = iLowest(Symbol(),LongPer,MODE_LOW,StopBar_Buy,0);
StopLevel = iLow(Symbol(),LongPer,SLevel);
if(StopLevel>Ask - (10*point) && StopPip_Buy > 0) StopLevel = NormalizeDouble(Ask-(StopPip_Buy*point), digits);
else StopLevel = 0;
}
if(Selling)
{
SLevel = iHighest(Symbol(),LongPer,MODE_HIGH,StopBar_Sell,0);
StopLevel = iHigh(Symbol(),LongPer,SLevel);
if(StopLevel<Bid + (10*point) && StopPip_Sell > 0) StopLevel = NormalizeDouble(Bid +(StopPip_Sell*point), digits);
else StopLevel = 0;
}
}
if(StopMode == 2)
{
if(Buying)
{
StopLevel = iLow(Symbol(),LongPer,StopBar_Buy);
if(StopLevel>Ask - (10*point) && StopPip_Buy > 0) StopLevel = NormalizeDouble(Ask-(StopPip_Buy*point), digits);
else StopLevel = 0;
}
if(Selling)
{
StopLevel = iHigh(Symbol(),LongPer,StopBar_Sell);
if(StopLevel<Bid + (10*point) && StopPip_Sell > 0) StopLevel = NormalizeDouble(Bid +(StopPip_Sell*point), digits);
else StopLevel = 0;
}
}
}
if(UseTakeProfit)
{
if(TakeProfitMode == 0)
{
if(Buying) TakeProfitLevel = NormalizeDouble(Ask+(TakeProfitPip_Buy*point), digits);
if(Selling) TakeProfitLevel = NormalizeDouble(Bid-(TakeProfitPip_Sell*point), digits);
}
if(TakeProfitMode == 1)
{
if(Buying)
{
SLevel = iLowest(Symbol(),LongPer,MODE_LOW,TakeProfitBar_Buy,0);
TakeProfitLevel = iLow(Symbol(),LongPer,SLevel);
if(TakeProfitLevel<Ask + (10*point) && TakeProfitPip_Buy > 0) TakeProfitLevel = NormalizeDouble(Ask+(TakeProfitPip_Buy*point), digits);
else TakeProfitLevel = 0;
}
if(Selling)
{
SLevel = iHighest(Symbol(),LongPer,MODE_HIGH,TakeProfitBar_Sell,0);
TakeProfitLevel = iHigh(Symbol(),LongPer,SLevel);
if(TakeProfitLevel>Bid - (10*point) && TakeProfitPip_Sell > 0) TakeProfitLevel = NormalizeDouble(Bid -(TakeProfitPip_Sell*point), digits);
else TakeProfitLevel = 0;
}
}
if(TakeProfitMode == 2)
{
if(Buying)
{
TakeProfitLevel = iLow(Symbol(),LongPer,TakeProfitBar_Buy);
if(TakeProfitLevel<Ask + (10*point) && TakeProfitPip_Buy > 0) TakeProfitLevel = NormalizeDouble(Ask+(TakeProfitPip_Buy*point), digits);
else TakeProfitLevel = 0;
}
if(Selling)
{
TakeProfitLevel = iHigh(Symbol(),LongPer,TakeProfitBar_Sell);
if(TakeProfitLevel>Bid - (10*point) && TakeProfitPip_Sell > 0) TakeProfitLevel = NormalizeDouble(Bid -(TakeProfitPip_Sell*point), digits);
else TakeProfitLevel = 0;
}
}
}
double res=0;
TradeLots = LotsOptimized();
while(TradeLots>Max_Lot_Size)
{
if(!Buying && !Selling) break;
//---- buy conditions
if(Buying)
{
res=OrderSend(Symbol(),OP_BUY,Max_Lot_Size,Ask,(5*point),StopLevel,TakeProfitLevel,TRADE_COMM,MAGICMA,0,Blue);
if(res < 0) {break;}
TradeLots = TradeLots - Max_Lot_Size;
}
//---- sell conditions
else if(Selling)
{
res=OrderSend(Symbol(),OP_SELL,Max_Lot_Size,Bid,(5*point),StopLevel,TakeProfitLevel,TRADE_COMM,MAGICMA,0,Red);
if(res < 0) {break;}
TradeLots = TradeLots - Max_Lot_Size;
}
}
if(TradeLots>Max_Lot_Size)
{
if(Buying)
{
Print("Error Opening Buy Orders....ceasing. Error #",GetLastError()," Lots left untraded = ",TradeLots);
return;
}
if(Selling)
{
Print("Error Opening Sell Orders....ceasing. Error #",GetLastError()," Lots left untraded = ",TradeLots);
return;
}
}
if(Buying)
{
res=OrderSend(Symbol(),OP_BUY,TradeLots,Ask,(8*point),StopLevel,TakeProfitLevel,TRADE_COMM,MAGICMA,0,Blue);
if(res > 0) return; else Print("Error Opening Buy Order...ceasing");
return;
}
else if(Selling)
{
res=OrderSend(Symbol(),OP_SELL,TradeLots,Bid,(8*point),StopLevel,TakeProfitLevel,TRADE_COMM,MAGICMA,0,Red);
if(res > 0) return; else Print("Error Opening Sell Order...ceasing");
return;
}
//----
return;
}
//+------------------------------------------------------------------+
//| Check for close order conditions |
//+------------------------------------------------------------------+
void CheckForClose()
{
//----
for(int i=OrdersTotal()-1;i>=0;i--)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
if(OrderMagicNumber()!=MAGICMA || OrderSymbol()!=Symbol()) continue;
//---- check order type
if(OrderType()==OP_BUY)
{
if(cExitBuy==true) OrderClose(OrderTicket(),OrderLots(),Bid,50,White);
}
if(OrderType()==OP_SELL)
{
if(cExitSell==true) OrderClose(OrderTicket(),OrderLots(),Ask,50,White);
}
}
}
//+------------------------------------------------------------------+
//| MoveTrailingStop() Function |
//+------------------------------------------------------------------+
void MoveTrailingStop()
{
int cnt;
bool moved = false;
double Trailer_buy, Trailer_sell, TrailBuffer=10*point, TrailMinB, TrailMinS;
int TBar_Buy, TBar_Sell, total;
if(TrailMode==0)
{
if(TrailPip_Buy>0) { Trailer_buy = NormalizeDouble(Ask-(TrailPip_Buy * point),digits); } else Trailer_buy=0;
if(TrailPip_Sell>0){ Trailer_sell = NormalizeDouble(Bid + (TrailPip_Sell * point),digits); } else Trailer_sell=0;
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES);
if(OrderType() <= OP_SELL && OrderSymbol()==Symbol() )
{
if( OrderMagicNumber() == MAGICMA)
{
if( OrderType()==OP_BUY && NormalizeDouble(OrderStopLoss(),digits) != Trailer_buy && Trailer_buy > 0)
{
if(Trailer_buy<Ask-TrailBuffer && Ask>OrderOpenPrice() && Trailer_buy > OrderStopLoss())
{
moved = OrderModify(OrderTicket(),OrderOpenPrice(),Trailer_buy,OrderTakeProfit(),0,Blue);
if(!moved) Print("Error on Modify - Buy");
}
}
if(OrderType()==OP_SELL && NormalizeDouble(OrderStopLoss(),digits) != Trailer_sell && Trailer_sell > 0)
{
if(Trailer_sell>Bid+TrailBuffer && Bid<OrderOpenPrice() && (Trailer_sell < OrderStopLoss() || OrderStopLoss()==0))
{
moved = OrderModify(OrderTicket(),OrderOpenPrice(),Trailer_sell,OrderTakeProfit(),0,Red);
if(!moved) Print("Error on Modify - Sell");
}
}
}
}// Ordertype() buy or sell and Same Symbol()
} // for Orders =
}
if(TrailMode==1)
{
if(TrailBar_Buy>0) { TBar_Buy=iLowest(Symbol(),0,MODE_LOW,TrailBar_Buy,0); Trailer_buy = NormalizeDouble(Low[TBar_Buy],digits); } else Trailer_buy=0;
if(TrailBar_Sell>0){ TBar_Sell=iHighest(Symbol(),0,MODE_HIGH,TrailBar_Sell,0); Trailer_sell = NormalizeDouble(High[TBar_Sell],digits); } else Trailer_sell=0;
if(TrailMin_Buy>0)TrailMinB = NormalizeDouble(TrailMin_Buy*point,digits); else TrailMinB=0;
if(TrailMin_Sell>0)TrailMinS = NormalizeDouble(TrailMin_Sell*point,digits); else TrailMinS=0;
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES);
if(OrderType() <= OP_SELL && OrderSymbol()==Symbol() )
{
if( OrderMagicNumber() == MAGICMA)
{
if( OrderType()==OP_BUY && NormalizeDouble(OrderStopLoss(),digits) != Trailer_buy && Trailer_buy > 0)
{
if(Trailer_buy<Ask-TrailMinB-TrailBuffer && Ask>OrderOpenPrice() && Trailer_buy > OrderStopLoss())
{
moved = OrderModify(OrderTicket(),OrderOpenPrice(),Trailer_buy,OrderTakeProfit(),0,Blue);
if(!moved) Print("Error on Modify - Buy");
}
}
if(OrderType()==OP_SELL && NormalizeDouble(OrderStopLoss(),digits) != Trailer_sell && Trailer_sell > 0)
{
if(Trailer_sell>Bid+TrailMinS+TrailBuffer && Bid<OrderOpenPrice() && (Trailer_sell < OrderStopLoss() || OrderStopLoss()==0))
{
moved = OrderModify(OrderTicket(),OrderOpenPrice(),Trailer_sell,OrderTakeProfit(),0,Red);
if(!moved) Print("Error on Modify - Sell");
}
}
}
}// Ordertype() buy or sell and Same Symbol()
} // for Orders =
} //Trail Mode == 1
if(TrailMode==2)
{
if(TrailBar_Buy>0) { Trailer_buy = NormalizeDouble(Low[TrailBar_Buy],digits); } else Trailer_buy=0;
if(TrailBar_Sell>0){ Trailer_sell = NormalizeDouble(High[TrailBar_Sell],digits); } else Trailer_sell=0;
if(TrailMin_Buy>0)TrailMinB = NormalizeDouble(TrailMin_Buy*point,digits); else TrailMinB=0;
if(TrailMin_Sell>0)TrailMinS = NormalizeDouble(TrailMin_Sell*point,digits); else TrailMinS=0;
total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES);
if(OrderType() <= OP_SELL && OrderSymbol()==Symbol() )
{
if( OrderMagicNumber() == MAGICMA)
{
if( OrderType()==OP_BUY && NormalizeDouble(OrderStopLoss(),digits) != Trailer_buy && Trailer_buy > 0)
{
if(Trailer_buy<Ask-TrailMinB-TrailBuffer && Ask>OrderOpenPrice() && Trailer_buy > OrderStopLoss())
{
moved = OrderModify(OrderTicket(),OrderOpenPrice(),Trailer_buy,OrderTakeProfit(),0,Blue);
if(!moved) Print("Error on Modify - Buy");
}
}
if(OrderType()==OP_SELL && NormalizeDouble(OrderStopLoss(),digits) != Trailer_sell && Trailer_sell > 0)
{
if(Trailer_sell>Bid+TrailMinS+TrailBuffer && Bid<OrderOpenPrice() && (Trailer_sell < OrderStopLoss() || OrderStopLoss()==0))
{
moved = OrderModify(OrderTicket(),OrderOpenPrice(),Trailer_sell,OrderTakeProfit(),0,Red);
if(!moved) Print("Error on Modify - Sell");
}
}
}
}// Ordertype() buy or sell and Same Symbol()
} // for Orders =
} //Trail Mode == 2
return(0);
}
//+------------------------------------------------------------------+
//| Start function |
//+------------------------------------------------------------------+
void start()
{
if(Digits<=4)
{
point=0.01;
digits=2;
}
else
{
point=0.0001;
digits=4;
}
//___________________________________ Testing Control only
if(LongPer!=5 && LongPer!=15 && LongPer!=30 && LongPer!=60 && LongPer!=240 && LongPer!=1440) return;
if(ShortPer!=5 && ShortPer!=15 && ShortPer!=30 && ShortPer!=60 && ShortPer!=240 && ShortPer!=1440) return;
//___________________________________ Trade only @ bar open
gotime = Time[0];
if(gotime == lastgotime) return;
lastgotime = gotime;
//___________________________________ Check & Move Trailing Stops
if(UseTrail) MoveTrailingStop();
//___________________________________ Develope Linear Regression Channel
double a,b,c,
sumy=0.0,
sumx=0.0,
sumxy=0.0,
sumx2=0.0,
h=0.0,l=0.0,
LR_Slope,
LR_Width;
int x;
ArrayInitialize(LR_line,0.0000);
for(int i=0; i<LinRegLen; i++)
{
sumy+=iClose(Symbol(),PERIOD_H4,i);
sumxy+=iClose(Symbol(),PERIOD_H4,i)*i;
sumx+=i;
sumx2+=i*i;
}
c=sumx2*LinRegLen-sumx*sumx;
if(c==0.0)
{
Alert("Error in linear regression!");
return;
}
// Line equation
b=(sumxy*LinRegLen-sumx*sumy)/c;
a=(sumy-sumx*b)/LinRegLen;
// Linear regression line in buffer
for(x=0;x<LinRegLen;x++)
{
LR_line[x]=a+b*x;
}
for(x=0;x<LinRegLen;x++)
{
if(iHigh(Symbol(),PERIOD_H4,x)-LR_line[x] > h) h = iHigh(Symbol(),PERIOD_H4,x)-LR_line[x];
if(LR_line[x] - iLow(Symbol(),PERIOD_H4,x)> l) l = LR_line[x] - iLow(Symbol(),PERIOD_H4,x);
}
// Drawing support - resistance lines
if (h>l)
{
for(x=0;x<LinRegLen;x++)
{
Sup_line[x]=a-h+b*x;
Res_line[x]=a+h+b*x;
}
}
else
{
for(x=0;x<LinRegLen;x++)
{
Sup_line[x]=a-l+b*x;
Res_line[x]=a+l+b*x;
}
}
LR_Slope = NormalizeDouble(MathAbs(LR_line[0] - LR_line[LinRegLen-1]), digits);
LR_Width = NormalizeDouble(Res_line[0] - Sup_line[0], digits);
Print(" LR Slope = ",LR_Slope," LR Channel Width = ",LR_Width);
//+------------------------------------------------------------------+
//| Trading conditions |
//+------------------------------------------------------------------+
double cRSX_0 = iCustom(NULL, ShortPer, "rsx",ShortRSX, 0, 1);
double cRSX_0P = iCustom(NULL, ShortPer, "rsx",ShortRSX, 0, 2);
double cRSX_1 = iCustom(NULL, LongPer, "rsx",LongRSX, 0, 1);
double cRSX_1P = iCustom(NULL, LongPer, "rsx",LongRSX, 0, LongTrendSpread);
if(TradeTrend)
{
cSell = cRSX_1 < LongParSell && cRSX_0 > ShortParSell && cRSX_1 < cRSX_1P && cRSX_0 < cRSX_0P;
cBuy = cRSX_1 > LongParBuy && cRSX_0 < ShortParBuy && cRSX_1 > cRSX_1P && cRSX_0 > cRSX_0P;
cExitBuy = cSell;
cExitSell = cBuy ;
}
//---- calculate open orders by current symbol
if(OpenOrders(Symbol())==0 && LR_Slope > LinRegTrade*point) CheckForOpen(cBuy, cSell);
if(OpenOrders(Symbol())!=0) CheckForClose();
//----
}
//+------------------------------------------------------------------+
Comments