//+------------------------------------------------------------------+ //| Auto_RXD.mq4 | //| Copyright Robbie Ruan | //| | //+------------------------------------------------------------------+ #property copyright "Copyright 2009 Robbie Ruan Ver 0.01" #property link "robbie.ruan@gmail.com" //---- input parameters extern int MagicNumberAI = 888; extern int MagicNumberAIReverse = 222; extern int MagicNumberGrid = 999; extern string NoteMode = "0 Indicator mode, 1 BTS Mode, 2 AI Short, 3 AI Long, 4 AI Filter and Normal"; extern int Mode = 0; extern bool NewOrderAllowed = true; extern bool EnableHourTrade = true; extern int HourTradeStartTime = 18; extern int HourTradeStopTime = 23; extern double Lots = 0.1; extern double MaxLots = 0; extern bool FreeMarginControlLots = false; extern double BaseLots = 0.1; extern double BaseFreeMargin = 2000; // example, evry 2000 USD make 0.1 Lot extern int Slippage = 1; extern bool EnableIndicatorManager = true; extern bool EnableOrderCloseManager = true; extern bool EnableTrailingStopManager = false; extern double ATRLongStopRatio = 100; extern double ATRShortStopRatio = 100; extern double BTS_TP = 50; //TP = 30 - 150 extern double BTS_SL = 50; //SL = 10 - 100 extern int BTS_p = 5; //p = 1 - 5 //Mode = 2 extern int Short_x1 = 100; //x = 1 - 200 extern int Short_x2 = 100; //x = 1 - 200 extern int Short_x3 = 100; //x = 1 - 200 extern int Short_x4 = 100; //x = 1 - 200 extern int Short_MA = 1; //MA = 1 - 5 extern double Short_TP = 1000; //TP = 30 - 150 extern double Short_SL = 1000; //SL = 10 - 100 extern int Short_p = 5; //p = 1 - 5 extern int Short_Threshold = 100; //Threshold = 80 - 120 //Mode = 3 extern int Long_x1 = 100; //x = 1 - 200 extern int Long_x2 = 100; //x = 1 - 200 extern int Long_x3 = 100; //x = 1 - 200 extern int Long_x4 = 100; //x = 1 - 200 extern int Long_MA = 1; //MA = 1 - 5 extern double Long_TP = 1000; //TP = 30 - 150 extern double Long_SL = 1000; //SL = 10 - 100 extern int Long_p = 5; //p = 1 - 5 extern int Long_Threshold = 100; //Threshold = 80 - 120 //Mode = 4 extern int Supervisor_x1 = 100; //x = 1 - 200 extern int Supervisor_x2 = 100; //x = 1 - 200 extern int Supervisor_x3 = 100; //x = 1 - 200 extern int Supervisor_x4 = 100; //x = 1 - 200 extern int Supervisor_MA = 1; //MA = 1 - 5 extern int Supervisor_p = 5; //p = 1 - 5 extern int Supervisor_Threshold = 100; //Threshold = 80 - 120 extern bool ADXControl = true; // when adx0 > adx1, and above 20, can orders extern int ADXPeriod = 14; extern double ADXThreshold = 21; extern bool SARControl = true; extern bool SARCrossNeeded = false; //need enter when just SAR crossing extern bool MTF_SARControl = false; // multi time fram SAR cotrol extern double SAR_Step = 0.02; extern double SAR_Maximum = 0.2; extern bool MACDControl = true; // macd0,1,2 above 0 make long, vice visa extern double MACD_FastEMA = 12; extern double MACD_SlowEMA = 26; extern double MACD_SMA = 9; extern bool MTF_MACDControl = false; extern bool MovingFiboControl = true; extern int MovingFiboPeriod = 9; extern double MovingFiboRetrace = 0.30; static int MovingFiboOld = 0; extern bool MAFiboControl = true; extern int MAFiboPeriod = 21; extern int MAFiboShift = 9; //extern int MAFiboMA_Mothod = 3; //"MODE_LWMA"; //extern int MAFiboApplied_Price = 6; //"PRICE_WEIGHTED"; extern double MAFiboRetrace = 0.30; static int MAFiboOld = 0; //extern bool OsMAControl = false; //extern bool MTF_OsMAControl = false; extern bool MAControl = true; extern int SMAPeriod = 21; extern int LWMAPeriod = 21; extern int MAThreshold = 1; extern bool ATR_TpSl_Enable = true; extern int ATR_Period = 14; extern bool CandleControl = true; // make long only after new high, short after new low extern bool FractalsControl = false; extern bool AOControl = false; extern bool ACControl = false; extern bool XOControl = true; extern bool XOCrossNeeded = false; extern double XOBoxSize = 20; extern bool OsEURControl = false; extern int MA_Period = 12; extern int MA_Shift = 5; extern int Price = 6; //Weighted close price, (high+low+close+close)/4 extern int MAMode = 3; //Linear weighted moving average. extern bool IchimokuControl = false; extern int Tenkan_Sen = 9; extern int Kijun_Sen = 26; extern int SenkouSpan_B = 52; static int prevtime = 0; static double SL = 10; static double TP = 10; //#define LONGDIRECTION 1 //#define SHORTDIRECTION -1 //+------------------------------------------------------------------+ //| expert start function | //+------------------------------------------------------------------+ int start() { int i,total; double ATR; if (Time[0] == prevtime) { return(0); } prevtime = Time[0]; if (! IsTradeAllowed() ) { again(); return(0); } if ( NewOrderAllowed == false ) { return(0); } if ( EnableTrailingStopManager == true ) { TrailingStopManager(); } if ( EnableHourTrade == true ) { if ( HourTradeStartTime < HourTradeStopTime ) { //example, trade just in 19->20->21->22 if (Hour() < HourTradeStartTime || Hour() > HourTradeStopTime ) { return(0); } } else if ( HourTradeStartTime > HourTradeStopTime ) { //example, trade just in 22->23->0->1 if ( Hour() < HourTradeStartTime && Hour() > HourTradeStopTime ) { return(0); } } else if ( HourTradeStartTime == HourTradeStopTime ) { return(0); } } if ( EnableOrderCloseManager == true ) { OrderCloseManager(); } //initial TP/SL set to BTS_TP/BTS_SL if(ATR_TpSl_Enable == true) { ATR = iATR(NULL,0,ATR_Period,0); TP = NormalizeDouble(4.0*ATR*BTS_TP/100.0,Digits); SL = NormalizeDouble(3.0*ATR*BTS_SL/100.0, Digits); } else { TP = BTS_TP*Point; SL = BTS_SL*Point; } int ticket = -1; RefreshRates(); double NewLots = Lots; if(FreeMarginControlLots == true) { NewLots = GetNewLots(); } double Supervisor = Supervisor(); if (Supervisor > 0) { //close reversed orders when doing Grid total = OrdersTotal(); for (i = 0; i < total; i++) { OrderSelect(i, SELECT_BY_POS, MODE_TRADES); if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumberGrid) { if ( OrderType() == OP_SELL) { //OrderClose(OrderTicket(),OrderLots(),Ask,1,CLR_NONE); } } } // if one long positions already exist, do not make new orders total = OrdersTotal(); for (i = 0; i < total; i++) { OrderSelect(i, SELECT_BY_POS, MODE_TRADES); if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumberAI) { if ( OrderType() == OP_BUY) return(0); } } //run here, it means no open long positions, so create one ticket = OrderSend(Symbol(), OP_BUY, NewLots, Ask, Slippage, Bid - SL, Bid + TP, WindowExpertName(), MagicNumberAI, 0, Blue); if (ticket < 0) { again(); } } else if (Supervisor < 0) { //close reversed orders when doing Grid total = OrdersTotal(); for (i = 0; i < total; i++) { OrderSelect(i, SELECT_BY_POS, MODE_TRADES); if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumberGrid) { if ( OrderType() == OP_BUY) { //OrderClose(OrderTicket(),OrderLots(),Bid,1,CLR_NONE); } } } // if short positions already exist, do not make new orders total = OrdersTotal(); for (i = 0; i < total; i++) { OrderSelect(i, SELECT_BY_POS, MODE_TRADES); if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumberAI) { if ( OrderType() == OP_SELL) return(0); } } //run here, it means no open long positions, so create one ticket = OrderSend(Symbol(), OP_SELL, NewLots, Bid, Slippage, Ask + SL, Ask - TP, WindowExpertName(), MagicNumberAI, 0, Red); if (ticket < 0) { again(); } } else if (Supervisor == 0) { BasicTradingSystem(); // BTS, make both long and short orders at the same time } //-- Exit -- return(0); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //Supervisor filter double Supervisor() { double ATR; if (Mode == 4) { if (Supervisor_Perceptron() > 0) { // Perceptron Long if ( Long_Perceptron() > 0 && ( !EnableIndicatorManager || IndicatorManager(1) == true) ) { if(ATR_TpSl_Enable == true) { ATR = iATR(NULL,0,ATR_Period,0); TP = NormalizeDouble(4.0*ATR*Long_TP/100.0,Digits); SL = NormalizeDouble(3.0*ATR*Long_SL/100.0, Digits); } else { TP = Long_TP*Point; SL = Long_SL*Point; } return(1); } } // Perceptron Short else if ( Short_Perceptron() < 0 && ( !EnableIndicatorManager || IndicatorManager(-1) == true) ) { if(ATR_TpSl_Enable == true) { ATR = iATR(NULL,0,ATR_Period,0); TP = NormalizeDouble(4.0*ATR*Short_TP/100.0,Digits); SL = NormalizeDouble(3.0*ATR*Short_SL/100.0, Digits); } else { TP = Short_TP*Point; SL = Short_SL*Point; } return(-1); } else return(0); } if (Mode == 3) { if ( Long_Perceptron() > 0 && ( !EnableIndicatorManager || IndicatorManager(1) == true) ) { if(ATR_TpSl_Enable == true) { ATR = iATR(NULL,0,ATR_Period,0); TP = NormalizeDouble(4.0*ATR*Long_TP/100.0,Digits); SL = NormalizeDouble(3.0*ATR*Long_SL/100.0, Digits); } else { TP = Long_TP*Point; SL = Long_SL*Point; } return(1); } else return(0); } if (Mode == 2) { if ( Short_Perceptron() < 0 && ( !EnableIndicatorManager || IndicatorManager(-1) == true) ) { if(ATR_TpSl_Enable == true) { ATR = iATR(NULL,0,ATR_Period,0); TP = NormalizeDouble(4.0*ATR*Short_TP/100.0,Digits); SL = NormalizeDouble(3.0*ATR*Short_SL/100.0, Digits); } else { TP = Short_TP*Point; SL = Short_SL*Point; } return(-1); } else return(0); } if (Mode == 1) { return(0); } //Mode = 0 in none AI mode,that means just use indicators to determine buy or sell if (Mode == 0) { if ( ( EnableIndicatorManager == true && IndicatorManager(1) == true) ) { if(ATR_TpSl_Enable == true) { ATR = iATR(NULL,0,ATR_Period,0); TP = NormalizeDouble(4.0*ATR*Long_TP/100.0,Digits); SL = NormalizeDouble(3.0*ATR*Long_SL/100.0, Digits); } else { TP = Long_TP*Point; SL = Long_SL*Point; } return(1); } else if ( ( EnableIndicatorManager == true && IndicatorManager(-1) == true) ) { if(ATR_TpSl_Enable == true) { ATR = iATR(NULL,0,ATR_Period,0); TP = NormalizeDouble(4.0*ATR*Short_TP/100.0,Digits); SL = NormalizeDouble(3.0*ATR*Short_SL/100.0, Digits); } else { TP = Short_TP*Point; SL = Short_SL*Point; } return(-1); } return(0); } return(0); // Mode nothing, just return 0 by default } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //short training double Short_Perceptron() { double w1 = Short_x1 - 100; double w2 = Short_x2 - 100; double w3 = Short_x3 - 100; double w4 = Short_x4 - 100; double a1 = iMA( NULL,0,Short_MA,0,MODE_LWMA,PRICE_CLOSE, 0 ) - iMA( NULL,0,Short_MA,0,MODE_LWMA,PRICE_WEIGHTED,Short_p ); double a2 = iMA( NULL,0,Short_MA,0,MODE_LWMA,PRICE_WEIGHTED,Short_p ) - iMA( NULL,0,Short_MA,0,MODE_LWMA,PRICE_WEIGHTED,Short_p*2 ); double a3 = iMA( NULL,0,Short_MA,0,MODE_LWMA,PRICE_WEIGHTED,Short_p*2 ) - iMA( NULL,0,Short_MA,0,MODE_LWMA,PRICE_WEIGHTED,Short_p*3 ); double a4 = iMA( NULL,0,Short_MA,0,MODE_LWMA,PRICE_WEIGHTED,Short_p*3 ) - iMA( NULL,0,Short_MA,0,MODE_LWMA,PRICE_WEIGHTED,Short_p*4 ); return(w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4 + Short_Threshold - 100 ); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //long training1 double Long_Perceptron() { double w1 = Long_x1 - 100; double w2 = Long_x2 - 100; double w3 = Long_x3 - 100; double w4 = Long_x4 - 100; double a1 = iMA( NULL,0,Long_MA,0,MODE_LWMA,PRICE_CLOSE, 0 ) - iMA( NULL,0,Long_MA,0,MODE_LWMA,PRICE_WEIGHTED,Long_p ); double a2 = iMA( NULL,0,Long_MA,0,MODE_LWMA,PRICE_WEIGHTED,Long_p ) - iMA( NULL,0,Long_MA,0,MODE_LWMA,PRICE_WEIGHTED,Long_p*2 ); double a3 = iMA( NULL,0,Long_MA,0,MODE_LWMA,PRICE_WEIGHTED,Long_p*2 ) - iMA( NULL,0,Long_MA,0,MODE_LWMA,PRICE_WEIGHTED,Long_p*3 ); double a4 = iMA( NULL,0,Long_MA,0,MODE_LWMA,PRICE_WEIGHTED,Long_p*3 ) - iMA( NULL,0,Long_MA,0,MODE_LWMA,PRICE_WEIGHTED,Long_p*4 ); return(w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4 + Long_Threshold - 100 ); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //long training2 double Supervisor_Perceptron() { double w1 = Supervisor_x1 - 100; double w2 = Supervisor_x2 - 100; double w3 = Supervisor_x3 - 100; double w4 = Supervisor_x4 - 100; double a1 = iMA( NULL,0,Supervisor_MA,0,MODE_LWMA,PRICE_CLOSE, 0 ) - iMA( NULL,0,Supervisor_MA,0,MODE_LWMA,PRICE_WEIGHTED,Supervisor_p ); double a2 = iMA( NULL,0,Supervisor_MA,0,MODE_LWMA,PRICE_WEIGHTED,Supervisor_p ) - iMA( NULL,0,Supervisor_MA,0,MODE_LWMA,PRICE_WEIGHTED,Supervisor_p*2 ); double a3 = iMA( NULL,0,Supervisor_MA,0,MODE_LWMA,PRICE_WEIGHTED,Supervisor_p*2 ) - iMA( NULL,0,Supervisor_MA,0,MODE_LWMA,PRICE_WEIGHTED,Supervisor_p*3 ); double a4 = iMA( NULL,0,Supervisor_MA,0,MODE_LWMA,PRICE_WEIGHTED,Supervisor_p*3 ) - iMA( NULL,0,Supervisor_MA,0,MODE_LWMA,PRICE_WEIGHTED,Supervisor_p*4 ); return(w1 * a1 + w2 * a2 + w3 * a3 + w4 * a4 + Supervisor_Threshold - 100 ); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //BTS double BasicTradingSystem() { //return(iCCI(Symbol(), 0, BTS_p, PRICE_OPEN, 0)); bool Flag_Long = false; bool Flag_Short = false; int total = OrdersTotal(); for (int i = 0; i < total; i++) { OrderSelect(i, SELECT_BY_POS, MODE_TRADES); if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumberGrid) { if ( OrderType() == OP_BUY) { Flag_Long = true; } if (OrderType() == OP_SELL) { Flag_Short = true; } } } if (Flag_Long == false) { //OrderSend(Symbol(), OP_BUY, lots, Ask, Slippage, Bid - SL * Point, Bid + TP * Point, WindowExpertName(), MagicNumberGrid, 0, Blue); } if (Flag_Short == false) { //OrderSend(Symbol(), OP_SELL, lots, Bid, Slippage, Ask + SL * Point, Ask - TP * Point, WindowExpertName(), MagicNumberGrid, 0, Red); } } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //try again void again() { prevtime = Time[1]; Sleep(30000); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //Control All Inidicator results bool IndicatorManager(int Direction) { if (Direction == 1) { return( (!IchimokuControl || IchimokuConfirm() == 1) && (!ADXControl || ADXConfirm() == 1) && (!MACDControl || MACDConfirm() == 1) && (!SARControl || SARConfirm() == 1) && (!MovingFiboControl || MovingFiboConfirm() == 1) && (!MAFiboControl || MAFiboConfirm() == 1) && (!XOControl || XOConfirm() == 1) && (!CandleControl || CandleConfirm(1) == 1) && (!MAControl || MAConfirm() == 1) && (!FractalsControl || FractalsConfirm(1) == 1) && (!AOControl || AOConfirm() == 1) && (!ACControl || ACConfirm() == 1) && // (!OsMAControl || OsMAConfirm() == 1) && (!OsEURControl || OsEURConfirm() == 1) ); } if (Direction == -1) { return( (!IchimokuControl || IchimokuConfirm() == -1) && (!ADXControl || ADXConfirm() == -1) && (!MACDControl || MACDConfirm() == -1) && (!SARControl || SARConfirm() == -1) && (!MovingFiboControl || MovingFiboConfirm() == -1) && (!MAFiboControl || MAFiboConfirm() == -1) && (!XOControl || XOConfirm() == -1) && (!CandleControl || CandleConfirm(-1) == -1) && (!MAControl || MAConfirm() == -1) && (!FractalsControl || FractalsConfirm(-1) == -1) && (!AOControl || AOConfirm() == -1) && (!ACControl || ACConfirm() == -1) && // (!OsMAControl || OsMAConfirm() == -1) && (!OsEURControl || OsEURConfirm() == -1) ); } return(false); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //ADX filter int ADXConfirm() { // add this if for speed up test if (ADXControl == true) { double ADX0 = iADX(NULL,0,ADXPeriod,PRICE_OPEN,MODE_MAIN,0); // double ADX1 = iADX(NULL,0,ADXPeriod,PRICE_OPEN,MODE_MAIN,1); double ADX_PLUSDI0 = iADX(NULL,0,ADXPeriod,PRICE_OPEN,MODE_PLUSDI,0); double ADX_MINUSDI0 = iADX(NULL,0,ADXPeriod,PRICE_OPEN,MODE_MINUSDI,0); if ( (ADX0 >= ADXThreshold) && (ADX_PLUSDI0 > ADX_MINUSDI0) )// && (ADX0 >= ADX1) ) { return(1); } if ( (ADX0 >= ADXThreshold) && (ADX_PLUSDI0 < ADX_MINUSDI0) )// && (ADX0 >= ADX1) ) { return(-1); } } return(0); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //MACD filter int MACDConfirm() { // add this if for speed up test if (MACDControl == true) { double MACD0, MACD1, SIGNAL0, MACD0_H4, SIGNAL0_H4; MACD0 = iMACD(NULL,0,MACD_FastEMA,MACD_SlowEMA,MACD_SMA,PRICE_OPEN,MODE_MAIN,0); MACD1 = iMACD(NULL,0,MACD_FastEMA,MACD_SlowEMA,MACD_SMA,PRICE_OPEN,MODE_MAIN,1); SIGNAL0 = iMACD(NULL,0,MACD_FastEMA,MACD_SlowEMA,MACD_SMA,PRICE_OPEN,MODE_SIGNAL,0); MACD0_H4 = iMACD(NULL,PERIOD_H4,12,26,9,PRICE_OPEN,MODE_MAIN,0); SIGNAL0_H4 = iMACD(NULL,PERIOD_H4,12,26,9,PRICE_OPEN,MODE_SIGNAL,0); if ( MACD0 > MACD1 && MACD0 > SIGNAL0 && MACD0 > 0 && (!MTF_MACDControl || MACD0_H4 > SIGNAL0_H4) ) { return(1); } if ( MACD0 < MACD1 && MACD0 < SIGNAL0 && MACD0 < 0 && (!MTF_MACDControl || MACD0_H4 < SIGNAL0_H4) ) { return(-1); } } return(0); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //OsMA filter //OsMA is actually iMACD(NULL,0,12,26,9,PRICE_OPEN,MODE_MAIN,0)-iMACD(NULL,0,12,26,9,PRICE_OPEN,MODE_SIGNAL,0);; //int OsMAConfirm() //{ // add this if for speed up test //if (OsMAControl == true) //{ // // double OsMA0 = iOsMA(NULL,0,12,26,9,PRICE_OPEN,0); // // double OsMA0_H4 = iOsMA(NULL,PERIOD_H4,12,26,9,PRICE_OPEN,0); // // if ( OsMA0 > 0 && (!MTF_OsMAControl || OsMA0_H4 > 0 ) ) // { // return(1); // } // // if ( OsMA0 < 0 && (!MTF_OsMAControl || OsMA0_H4 < 0 ) ) // { // return(-1); // } // //} // // return(0); //} //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //SAR filter int SARConfirm() { // add this if for speed up test if (SARControl == true) { double SAR0 = iSAR(NULL,0,SAR_Step,SAR_Maximum,0); double SAR1 = iSAR(NULL,0,SAR_Step,SAR_Maximum,1); double SAR2 = iSAR(NULL,0,SAR_Step,SAR_Maximum,2); double SAR0_H4 = iSAR(NULL,PERIOD_H4,SAR_Step,SAR_Maximum,0); //indicate long double Low0_H4 = iLow(NULL,PERIOD_H4,0); if( SAR0 < Low[0] && SAR1 < Close[1] && (!SARCrossNeeded || SAR2 > High[2]) && (!MTF_SARControl || SAR0_H4 < Low0_H4) ) { return(1); } // indicate short double High0_H4 = iHigh(NULL,PERIOD_H4,0); if( SAR0 > High[0] && SAR1 > Close[1] && (!SARCrossNeeded || SAR2 < Low[2]) && (!MTF_SARControl || SAR0_H4 >High0_H4) ) { return(-1); } } return(0); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //Candle filter int CandleConfirm(int Direction) { // add this if for speed up test if (CandleControl == true) { if (Direction == 1 ) { if ( High[1] > High[2] )// && Close[1] > Open[1] )// && Low1 > Low2 ) { return(1); } } if (Direction == -1 ) { if ( Low[1] < Low[2] )// && Close[1] < Open[1] )// && High1 < High2 ) { return(-1); } } } return(0); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //MA filter int MAConfirm() { // add this if for speed up test if (MAControl == true) { double LWMA = iMA(NULL,0,LWMAPeriod,0,MODE_LWMA,PRICE_WEIGHTED,1); double SMA = iMA(NULL,0,SMAPeriod,0,MODE_SMA,PRICE_CLOSE,1); double Delta = LWMA - SMA; if ( Delta > MAThreshold*Point ) { return(1); } if ( (Delta < 0) && (MathAbs(Delta) > MAThreshold*Point) ) { return(-1); } } return(0); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //Fractal filter int FractalsConfirm(int Direction) { // add this if for speed up test if (FractalsControl == true) { if ( Direction == 1 ) { double FractalsUpper = iFractals(NULL,0,MODE_UPPER,3); if ( FractalsUpper == 0 || High[0] > FractalsUpper ) { return(1); } } if ( Direction == -1 ) { double FractalsLower = iFractals(NULL,0,MODE_LOWER,3); if ( FractalsLower == 0 || Low[0] < FractalsLower ) { return(-1); } } } return(0); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //AO filter //AO is actually iMACD(NULL,0,5,34,5,PRICE_MEDIAN,MODE_MAIN,0); int AOConfirm() { // add this if for speed up test if (AOControl == true) { double AO0 = iAO(NULL,0,0); double AO1 = iAO(NULL,0,1); if ( AO0 > 0 )// && AO0 > AO1) { return(1); } if ( AO0 < 0 )// && AO0 < AO1) { return(-1); } } return(0); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //AC filter //AC is actually AO-SMA(AO, 5), so it equals to iMACD(NULL,0,5,34,5,PRICE_MEDIAN,MODE_MAIN,0)-iMACD(NULL,0,5,34,5,PRICE_MEDIAN,MODE_SIGNAL,0);; int ACConfirm() { // add this if for speed up test if (ACControl == true) { double AC0 = iAC(NULL,0,0); //double AC1 = iAC(NULL,0,1); if (AC0 > 0) //&& AC0 > AC1) { return(1); } if (AC0 < 0) //&& AC0 < AC1) { return(-1); } } return(0); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //Ichimoku filter int IchimokuConfirm() { // add this if for speed up test if (IchimokuControl == true) { //the BaseLine ( KIJUN SEN ) is a calculation of the ( highest high + lowest low )/2 over 26(Kijun_Sen) periods. double BaseLine = iIchimoku(NULL,0,Tenkan_Sen,Kijun_Sen,SenkouSpan_B,MODE_KIJUNSEN, 0); //the ConversionLine is the same calc, ( highest high + lowest low )/2 but over 9(Tenkan_Sen) periods. double ConversionLine = iIchimoku(NULL,0,Tenkan_Sen,Kijun_Sen,SenkouSpan_B,MODE_TENKANSEN, 0); //the DelayLine is the closing price 26(Kijun_Sen) periods behind the current period. double DelayLine = iIchimoku(NULL,0,Tenkan_Sen,Kijun_Sen,SenkouSpan_B,MODE_CHINKOUSPAN,Kijun_Sen); //the LeadingSpanA is the ( ConversionLine + BaseLine )/2 with the results displaced forward by 26(Kijun_Sen) periods double LeadingSpanA = iIchimoku(NULL,0,Tenkan_Sen,Kijun_Sen,SenkouSpan_B,MODE_SENKOUSPANA,0); //the LeadingSpanB is the ( highest high + lowest low )/2 over the past 52(SenkouSpan_B) periods and displaced forward 26(Kijun_Sen) periods. double LeadingSpanB = iIchimoku(NULL,0,Tenkan_Sen,Kijun_Sen,SenkouSpan_B,MODE_SENKOUSPANB,0); if ( (ConversionLine > BaseLine) )// && ( (Close[0] > LeadingSpanA) && (Close[0] > LeadingSpanB) ) && (DelayLine >= Close[Kijun_Sen]) ) { return(1); } if ( (ConversionLine < BaseLine) )// && ( (Close[0] < LeadingSpanA) && (Close[0] < LeadingSpanB) ) && (DelayLine <= Close[Kijun_Sen]) ) { return(-1); } } return(0); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //OsEUR filter int OsEURConfirm() { // add this if for speed up test if (OsEURControl == true) { int i = 0; double EURIndex; EURIndex = (iMA("EURUSD",0,MA_Period,0,MAMode,Price,i) - iMA("EURUSD",0,MA_Period,0,MAMode,Price,i+MA_Shift)) * MathPow(10,MarketInfo("EURUSD",MODE_DIGITS)) + (iMA("EURGBP",0,MA_Period,0,MAMode,Price,i) - iMA("EURGBP",0,MA_Period,0,MAMode,Price,i+MA_Shift)) * MathPow(10,MarketInfo("EURGBP",MODE_DIGITS)) + (iMA("EURCHF",0,MA_Period,0,MAMode,Price,i) - iMA("EURCHF",0,MA_Period,0,MAMode,Price,i+MA_Shift)) * MathPow(10,MarketInfo("EURCHF",MODE_DIGITS)) + (iMA("EURJPY",0,MA_Period,0,MAMode,Price,i) - iMA("EURJPY",0,MA_Period,0,MAMode,Price,i+MA_Shift)) * MathPow(10,MarketInfo("EURJPY",MODE_DIGITS)) + (iMA("EURCAD",0,MA_Period,0,MAMode,Price,i) - iMA("EURCAD",0,MA_Period,0,MAMode,Price,i+MA_Shift)) * MathPow(10,MarketInfo("EURCAD",MODE_DIGITS)) + (iMA("EURAUD",0,MA_Period,0,MAMode,Price,i) - iMA("EURAUD",0,MA_Period,0,MAMode,Price,i+MA_Shift)) * MathPow(10,MarketInfo("EURAUD",MODE_DIGITS)) ; if (EURIndex > 0 ) { return(1); } if (EURIndex < 0 ) { return(-1); } } return(0); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //XO filter int XOConfirm() { //for speed up test if( XOControl == true ) { int CurrentBar; int Counter = 0; double X_High,O_Low,CurrentPrice; double XO_UpFlag,XO_DownFlag,XO_UpFlag2,XO_DownFlag2; XO_UpFlag = 0; XO_DownFlag = 0; XO_UpFlag2 = 0; XO_DownFlag2 = 0; for(int i=200;i>=1;i--) { XO_UpFlag2 = XO_UpFlag; XO_DownFlag2 = XO_DownFlag; CurrentBar = i; if (Counter<1) { X_High=Close[CurrentBar]; O_Low =Close[CurrentBar]; Counter=1; } CurrentPrice=Close[CurrentBar]; if (CurrentPrice>(X_High+XOBoxSize*Point)) { Counter +=1; X_High = CurrentPrice; O_Low = CurrentPrice-XOBoxSize*Point; XO_UpFlag = 1; XO_DownFlag = 0; } if (CurrentPrice<(O_Low-XOBoxSize*Point)) { Counter += 1; O_Low = CurrentPrice; X_High = CurrentPrice+XOBoxSize*Point; XO_UpFlag = 0; XO_DownFlag = 1; } } if((XO_UpFlag == 1) && ( !XOCrossNeeded || XO_DownFlag2 == 1 ) ) { return(1); } if((XO_DownFlag == 1) && ( !XOCrossNeeded || XO_UpFlag2 == 1 ) ) { return(-1); } } return(0); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- // Moving Fibonacci filter int MovingFiboConfirm() { //for speed up test if ( MovingFiboControl == true ) { int MovingFiboNew; double MaxHigh = High[iHighest(NULL,0,MODE_HIGH,MovingFiboPeriod,1)]; double MaxLow = Low[iLowest(NULL,0,MODE_LOW,MovingFiboPeriod,1)]; double Risistance = MaxHigh - (MaxHigh-MaxLow)*MovingFiboRetrace; // = High - 30% double Support = MaxLow + (MaxHigh-MaxLow)*MovingFiboRetrace; // = Low + 30% MovingFiboNew = MovingFiboOld; // if no new assign, MovingFiboNew remains the same with the old one. if (Close[1] > Risistance ) { MovingFiboNew = 1; } if (Close[1] < Support ) { MovingFiboNew = -1; } MovingFiboOld = MovingFiboNew; // store MovingFiboNew value to MovingFiboOld. return(MovingFiboNew); } return(0); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- // Moving Average Fibonacci filter int MAFiboConfirm() { //for speed up test if ( MAFiboControl == true ) { int i, MAFiboNew; double tmp, MAMaxLow, MAMaxHigh; tmp = iMA(Symbol(),0,MAFiboPeriod,0,MODE_LWMA,PRICE_WEIGHTED,1); MAMaxHigh = tmp; MAMaxLow = tmp; for (i=1; i<=MAFiboShift; i++ ) { tmp = iMA(Symbol(),0,MAFiboPeriod,0,MODE_LWMA,PRICE_WEIGHTED,i); if ( tmp > MAMaxHigh ) { MAMaxHigh = tmp; } if ( tmp < MAMaxLow ) { MAMaxLow = tmp; } } double MARisistance = MAMaxHigh - (MAMaxHigh-MAMaxLow)*MAFiboRetrace; // = MAHigh - 30% double MASupport = MAMaxLow + (MAMaxHigh-MAMaxLow)*MAFiboRetrace; // = MALow + 30% MAFiboNew = MAFiboOld; // if no new assign, MAFiboNew remains the same with the old one. if (Close[1] > MARisistance ) { MAFiboNew = 1; } if (Close[1] < MASupport ) { MAFiboNew = -1; } MAFiboOld = MAFiboNew; // store MAFiboNew value to MovingFiboOld. return(MAFiboNew); } return(0); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //GetNewLots function double GetNewLots() { double NewLots = BaseLots; double FreeMarginPercentage = AccountFreeMargin()/AccountBalance(); int FreeMarginTimes = MathFloor( (AccountFreeMargin()/BaseFreeMargin) * FreeMarginPercentage ); // how many time is present FreeMargin times BaseFreeMargin if(FreeMarginTimes >= 1) { NewLots = BaseLots*FreeMarginTimes; } if ( MaxLots > 0 && NewLots > MaxLots ) { NewLots = MaxLots; } return(NewLots); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- //OrderCloseManager function int OrderCloseManager() { int i, Flag; double SAR0 = iSAR(NULL,0,SAR_Step,SAR_Maximum,0); bool CloseSELLReason = ( SAR0 < Low[0] ) ;// || ( Low[1] > Low[3] && Low[2] > Low[3] ); bool CloseBUYReason = ( SAR0 > High[0] ) ;// || ( High[1] < High[3] && High[2] < High[3] ); if ( CloseSELLReason == true) { int total = OrdersTotal(); for (i = 0; i < total; i++) { OrderSelect(i, SELECT_BY_POS, MODE_TRADES); if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumberAI) { if ( OrderType() == OP_SELL) { OrderClose(OrderTicket(),OrderLots(),Ask,1,CLR_NONE); Flag = 1; } } } } if (CloseBUYReason == true ) { total = OrdersTotal(); for (i = 0; i < total; i++) { OrderSelect(i, SELECT_BY_POS, MODE_TRADES); if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumberAI) { if ( OrderType() == OP_BUY) { OrderClose(OrderTicket(),OrderLots(),Bid,1,CLR_NONE); Flag = -1; } } } } return(Flag); } //--------------------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------------------- // Trailing Stop function: trailing by ATR int TrailingStopManager() { int Counter = 0; for(int i=0;i 0) { if(NormalizeDouble(NewLongStopLoss - OrderStopLoss(), Digits) > 0) { Print("................................"); OrderModify(OrderTicket(),OrderOpenPrice(),NewLongStopLoss,OrderTakeProfit(),OrderExpiration(),CLR_NONE); Counter += 1; } } } // Long orders trailing stop end here // short trailing stop if(OrderType() == OP_SELL) { shifttime = iBarShift(Symbol(),0,OrderOpenTime(),0); //Print("Shortshifttime:::::::::::",shifttime); double NewMaxLow = Low[iLowest(NULL,0,MODE_LOW,shifttime,0)]; double NewShortStopLoss = NewMaxLow + iATR(NULL,0,14,0)*3.0*ATRShortStopRatio/100.0; //Print("NewMaxLow::::::::::::::::",NewMaxLow); //Print("NewsShortStopLoss::::::::::::::::::::::",NewShortStopLoss); //Print("NormalizeDouble(NewShortStopLoss - OrderStopLoss(), Digits):::::::::::::::::::",NormalizeDouble(NewShortStopLoss - OrderStopLoss(), Digits)); if(NormalizeDouble(NewShortStopLoss - OrderOpenPrice(), Digits) < 0) { if(NormalizeDouble(NewShortStopLoss - OrderStopLoss(), Digits) < 0) { Print("................................"); OrderModify(OrderTicket(),OrderOpenPrice(),NewShortStopLoss,OrderTakeProfit(),OrderExpiration(),CLR_NONE); Counter += 1; } } } // sell orders trailing stop end here }// for end here return(Counter); } //---------------------------------------------------------------------------------------------------------------