//+------------------------------------------------------------------+
//| TrendAndDiver |
//| Copyright © 2005, MetaQuotes Software Corp. |
//| http://www.metaquotes.net |
//+------------------------------------------------------------------+
#include <WinUser32.mqh>
#include <stderror.mqh>
#include <stdlib.mqh>
//+------------------------------------------------------------------+
//| EX4 imports |
//+------------------------------------------------------------------+
#import "Diver.ex4"
int BreackUpTrendCondition (int TimeFrame, int MaxWaveNum);
int BreackDownTrendCondition (int TimeFrame, int WaveNum);
bool SeachDiv(int TimeFrame, int MaxWaveNum, int StartBar);
bool SeachConv(int TimeFrame,int cMaxWaveNum,int StartBar);
bool DiverKind(int SeekBar, int TimeFrame);
bool ConvKind(int SeekBar, int TimeFrame);
void dinstall(int StrBar);
void cinstall(int StrBar);
void AddpipsInit(int spips,int bpips);
void PeriodInit(int P1,int P2);
#import
//+------------------------------------------------------------------+
#property copyright "Mikhail Sapozhnikov "
#property link "http://www.metaquotes.net"
//---- input parameters
//extern int trend = 1;
extern double Lots = 1;
extern double StopLoss = 150;
extern double TakeProfit = 0;
extern double dADX0 = 65;
extern double dADX1 = 30 ;
extern double cADX0 = 30;
extern double Bulls100=0.041 ;
//extern double Bears100=-0.02;
extern double MaxStStopSellonDn= 25;
extern double MinStSellonDn=53;
extern int cWaveTopNum = 12;
extern int dWaveTopNum = 8;
extern double dMinTp = 600;
extern int Days=5 ;
extern int OrderNum=3;
extern int MainOrderNum=2;
extern int LocalOrderNum=2;
extern int LocalOrderNum1=3;
extern double Boundary=0.5;
extern int Spips=25;
extern int Bpips=0;
// ----- Òðåíäîâûå êîíñòàíòû ------
#define Up 3
#define Flat 2
#define Down 1
#define Unknown -1
#define NoSignal 9
#define Ready 8
#define Ready1 7
#define Ready2 6
#define Go 1
#define TakeYourTime 10
#define MainLongMagic 234
#define LongMagic 2345
#define LongMagic1 2346
#define LongMagic2 2347
#define MainShortMagic 123
#define ShortMagic 1235
#define ShortMagic1 1236
#define ShortMagic2 1237
int cMainFrame=PERIOD_D1;
int cSlaveFrame=PERIOD_W1;
int dMainFrame=PERIOD_W1;
int dSlaveFrame=PERIOD_H4;
int shift=0; //Ãîòîâèìñÿ ê àíàëèçó íà ïðîøëûõ áàðàõ
double W1MinBears=-0.055 ;
int Week = 5;
bool Gb,test1;
int total,OrderCount; //îáùåå êîë-âî îòêðûòûõ îðäåðîâ
int lastCloseMagic, lastCloseProf;
int sMagicNum,sMagicNum1, sMagicNum2, sMainMagicNum,
lMagicNum, lMagicNum1, lMagicNum2, lMainMagicNum;
int lWaitMagicCnt;
int sWeekMnMagicCnt,lWeekMnMagicCnt,lDayMagicCnt, sDayMagicCnt;
int sDaySmallMagicCnt, sDaySmallMagic2Cnt, lDaySmallMagicCnt,lDaySmallMagic2Cnt;
datetime LastMainDnGoWeek,LastMainUpGoWeek;
datetime LastLocDnGoDay,LastLocUpGoDay;
datetime LastSmallUpDay, LastSmallUpDay2, LastSmallDnDay, LastSmallDn2Day;
double StartBalance, HPR, SumHPR, AHPR, GHPR;
int BarsNum=500, BullsP=13, BearsP=13, ADXperiod=13, adx55step=16;
//== ñèãíàëû ===
double buyADX, sellADX,sellADXDmax, sellADXWmax;
int WaitUp, WaitDn, WaitCorre, WaitCont, WaitSmallCorr,WaitSmallCont,
WaitSmallUp, WaitSmallDn;
int sStartWaitingTime,bStartWaitingTime,sStartCorreTime, sStartTakeYourTime; //íà÷àëî îòñ÷åòà
int MainTrend, LocalTrend, SmallTrend,MA100Vector;
int WaveNum, LongCall, ShortCall;
bool SetGlobVar(string Name, int Val)
{ datetime Now=TimeCurrent(), r=0;
while (!(r>0 || TimeCurrent()-Now>10))
r=GlobalVariableSet(Name,Val);
if(r==0)
{ Print("Oøèáêà ",GetLastError()," ãëîáàëüíîé ïåðåìåííîé ",Name);
return(false);
}
return(true);
}
//--------------------------
bool LastCloseParam()
{ int i , histotal= OrdersHistoryTotal();
int mag;
bool Y;
for( i=histotal-1;i>=0;i--)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==false)
{ Print("Error in history!");lastCloseProf=0 ;break; }
if(OrderSymbol()!=Symbol() || OrderType()>OP_SELL) continue;
lastCloseMagic=OrderMagicNumber();
if ((lastCloseMagic!=MainLongMagic
&& lastCloseMagic!=LongMagic
&& lastCloseMagic!=LongMagic1
&& lastCloseMagic!=LongMagic2
&& lastCloseMagic!=MainShortMagic
&& lastCloseMagic!=ShortMagic
&& lastCloseMagic!=ShortMagic1
&& lastCloseMagic!=ShortMagic2 ))
{Y=false;continue;}
Y=true;
lastCloseProf=OrderProfit();
break;
}
if(lastCloseProf>=0) Y=true;
else Y=false;
return(Y);
}
//--------------------------
void OrdersMagic()
{ int cn;
double Prof;
lMagicNum=0;
lMagicNum1=0;
lMagicNum2=0;
lMainMagicNum=0;
lWeekMnMagicCnt=0;
lDayMagicCnt=0;
lDaySmallMagicCnt=0;
lDaySmallMagic2Cnt=0;
sMagicNum=0;
sMagicNum1=0;
sMagicNum2=0;
sMainMagicNum=0;
sWeekMnMagicCnt=0;
sDayMagicCnt=0;
sDaySmallMagicCnt=0;
sDaySmallMagic2Cnt=0;
lWaitMagicCnt=0;
for(cn=0;cn<total;cn++)
{//for
if( OrderSelect(cn, SELECT_BY_POS, MODE_TRADES)==true)
if(OrderType()<=OP_SELL &&
OrderSymbol()==Symbol()) // check for symbol
{//1
if(OrderType()==OP_BUY) // long position is opened
{//2
if(OrderMagicNumber()==MainLongMagic)
{ lMainMagicNum++; LastMainUpGoWeek=OrderOpenTime();
if(TimeCurrent()- LastMainUpGoWeek<86400*10)
lWeekMnMagicCnt++;
continue;
}
if(OrderMagicNumber()==LongMagic)
{lMagicNum++; LastLocUpGoDay=OrderOpenTime();
if(TimeCurrent()- LastLocUpGoDay<86400*3)
lDayMagicCnt++;
continue;
}
if(OrderMagicNumber()==LongMagic1)
{lMagicNum1++; LastSmallUpDay=OrderOpenTime();
if( TimeCurrent()-LastSmallUpDay<86400*2)
lDaySmallMagicCnt++;
if(Bid-OrderOpenPrice()>90*Point && !(OrderStopLoss()==OrderOpenPrice()) )
OrderModify(OrderTicket(),Bid-20*Point,OrderOpenPrice(),OrderTakeProfit(),0,Gold);
if(Bid-OrderOpenPrice()>200*Point)
{LocalTrend=Up; GlobalVariableSet("gLocalTrend"+Symbol(),Up);}
continue;
}
if(OrderMagicNumber()==LongMagic2)
{lMagicNum2++; LastSmallUpDay2=OrderOpenTime();
if( TimeCurrent()-LastSmallUpDay2<86400*2)
lDaySmallMagic2Cnt++;
continue;
}
}
if(OrderType()==OP_SELL)
{if(OrderMagicNumber()==MainShortMagic)
{sMainMagicNum++;LastMainDnGoWeek=OrderOpenTime();
if(TimeCurrent()- LastMainDnGoWeek<86400*10)
sWeekMnMagicCnt++;
continue;
}
if(OrderMagicNumber()==ShortMagic)
{sMagicNum++;LastLocDnGoDay=OrderOpenTime();
if(TimeCurrent()- LastLocDnGoDay<86400*5)
sDayMagicCnt++;
if( TimeCurrent()-LastLocDnGoDay>86400*Days
)
{ if(iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,1)
>iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,10))
{Prof=MathFloor(10000*iIchimoku(NULL, dMainFrame, 9, 26, 52, MODE_KIJUNSEN, 0))/10000;
if (Prof-MathFloor(10000*iIchimoku(NULL, dMainFrame, 9, 26, 52, MODE_KIJUNSEN, 1))/10000>3*Point
&& Prof!=OrderTakeProfit() )
{ if(sellADXDmax>=59)
{ if( (sellADXDmax<=68 || MainTrend==Down) && OrderOpenPrice()-Bid >15*Point
&& OrderStopLoss()!=OrderOpenPrice())
OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice(),Prof,0,Gold);
}
}
}
}
continue;
}
if(OrderMagicNumber()==ShortMagic1)
{sMagicNum1++; LastSmallDnDay=OrderOpenTime();
if(TimeCurrent()- LastSmallDnDay<86400*3)
sDaySmallMagicCnt++;
continue;
}
if(OrderMagicNumber()==ShortMagic2)
{sMagicNum2++; LastSmallDn2Day=OrderOpenTime();
if(TimeCurrent()- LastSmallDn2Day<86400*1)
sDaySmallMagic2Cnt++;
if( iMA(NULL,240,21,0,MODE_EMA,PRICE_CLOSE,21)-
iMA(NULL,240,21,0,MODE_EMA,PRICE_CLOSE,1)>=90*Point
&& OrderTakeProfit()>0)
OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),0,0,Gold);
}
continue;
}
}
}
}
//==============================
int CheckADX (int TimeFrame, int P, int Start, int adxStep)
{
if ( iADX(NULL,TimeFrame,P,PRICE_HIGH,MODE_MAIN,Start)<
iADX(NULL,TimeFrame,P,PRICE_HIGH,MODE_MAIN,Start+adxStep)
)
return(Down);
else
{if ( iADX(NULL,TimeFrame,P,PRICE_HIGH,MODE_MAIN,Start)>
iADX(NULL,TimeFrame,P,PRICE_HIGH,MODE_MAIN,Start+adxStep))
return(Up);}
return(Flat);
}
//--------------------------------------------------------------
int CheckiMa(int TimeFrame, int P, int Mode, int Start, int Step)
{
if ( iMA(NULL,TimeFrame,P,0,PRICE_CLOSE,Mode,Start)<
iMA(NULL,TimeFrame,P,0,PRICE_CLOSE,Mode,Start+Step)
)
return(Down);
else
{if (iMA(NULL,TimeFrame,P,0,PRICE_CLOSE,Mode,Start)>
iMA(NULL,TimeFrame,P,0,PRICE_CLOSE,Mode,Start+Step))
return(Up);}
return(Flat);
}
//===================================================================+
double minStoch(int Frame, int StartBar, int BarCnt )
{ int i,j;
double minStoch;
minStoch=iStochastic(NULL,Frame,8,3,3,MODE_SMA,0,MODE_MAIN, StartBar);
for (i=StartBar+1;i<=StartBar+BarCnt;i++)
{ if(minStoch>iStochastic(NULL,Frame,8,3,3,MODE_SMA,0,MODE_MAIN, i))
minStoch=iStochastic(NULL,Frame,8,3,3,MODE_SMA,0,MODE_MAIN, i);
}//for
return(minStoch);
}
//===================================================================+
double maxADX(int Frame, int StartBar, int BarCnt )
{ int i,j;
double maxAD=iADX(NULL,Frame,13,PRICE_HIGH,MODE_MAIN,StartBar);
for (i=StartBar+1;i<=StartBar+BarCnt;i++)
{ if(maxAD<iADX(NULL,Frame,13,PRICE_HIGH,MODE_MAIN,i))
maxAD=iADX(NULL,Frame,13,PRICE_HIGH,MODE_MAIN,i);
}//for
return(maxAD);
}
//===================================================================+
double BearForce(int Frame, int BarCnt )
{ int i,j;
double Bear;
Bear= iBearsPower( NULL, Frame, 13, PRICE_CLOSE, 1);
for (i=2;i<=BarCnt;i++)
{ if(Bear>iBearsPower( NULL, Frame, 13, PRICE_CLOSE, i))
Bear=iBearsPower( NULL, Frame, 13, PRICE_CLOSE, i);
}//for
return(Bear);
}
double BullDecline(int Frame, int BarCnt )
{ int i,j;
double Bull;
Bull= iBullsPower( NULL, Frame, 13, PRICE_CLOSE, 1);
for (i=2;i<=BarCnt;i++)
{ if(Bull>iBullsPower( NULL, Frame, 13, PRICE_CLOSE, i))
Bull=iBullsPower( NULL, Frame, 13, PRICE_CLOSE, i);
}//for
return(Bull);
}
//+------------------------------------------------------------------+
// óñëîâèÿ äëÿ äèâåðãåíöèè
//+------------------------------------------------------------------+
double dStrongCond (int TimeFrame, double dADXhigh, int StBar)
{ double tmpADX;
tmpADX=iADX(NULL,TimeFrame,ADXperiod,PRICE_HIGH,MODE_MAIN,StBar);
if ( ( tmpADX>dADXhigh
&& iADX(NULL,TimeFrame,ADXperiod,PRICE_HIGH,MODE_PLUSDI,StBar+1)>
iADX(NULL,TimeFrame,ADXperiod,PRICE_HIGH,MODE_MINUSDI,StBar+1))
)
return(tmpADX);
else
return(0);
}
//+------------------------------------------------------------------+
// óñëîâèÿ äëÿ êîíâåðãåíöèè
//+------------------------------------------------------------------+
double cMidlCond(int TimeFrame,int applied_price, double cADXhigh, int StBar)
{
double tmpADX;
tmpADX=iADX(NULL,TimeFrame,ADXperiod,applied_price,MODE_MAIN,StBar);
if ( ( tmpADX>cADXhigh
&& iADX(NULL,TimeFrame,ADXperiod,applied_price,MODE_PLUSDI,StBar+1)<
iADX(NULL,TimeFrame,ADXperiod,applied_price,MODE_MINUSDI,StBar+1))
)
return(tmpADX);
else
return(0);
}
//+------------------------------------------------------------------+
//| expert function for short
//+------------------------------------------------------------------+
int MainShortOrder(int OrderCnt, int MagNum, double sTP=0)
{ datetime Begin=TimeCurrent();
double SL; // StopLoss â ïóíêòàõ
int mg, error,result;
bool Y;
//----
if( total<OrderNum )
{Y=true;
mg=MagNum;
switch (mg)
{
case MainShortMagic :
{ if (
sMainMagicNum>=MainOrderNum
|| sWeekMnMagicCnt>=1 )
Y=false;
else SL= iHigh(NULL,dMainFrame,0)+250*Point;
}
break;
case ShortMagic :
if (sMagicNum>=LocalOrderNum
|| sDayMagicCnt>=1)
Y=false;
else SL= iHigh(NULL,dMainFrame,0)+StopLoss*Point;
break;
case ShortMagic1 :
if (sMagicNum1>=LocalOrderNum1
|| sDaySmallMagicCnt>=1 )
Y=false;
else SL= iHigh(NULL,dMainFrame,0)+StopLoss*Point;
break;
case ShortMagic2 :
{if (sMagicNum2>=LocalOrderNum1
|| sDaySmallMagic2Cnt>=1 )
Y=false;
else SL= iHigh(NULL,dMainFrame,0)+80*Point;
}
break;
}//sw
}else Y=false;
if(Y )
{
result= OrderSend(Symbol(),OP_SELL,Lots,Bid,3,SL,
sTP,"",mg,0,White);
if (result==-1)
{error=GetLastError();
Print("error(",error,"): ",ErrorDescription(error));
if(!IsTesting())
{while(!( result>0 || TimeCurrent()-Begin>20))
{Sleep(1000); RefreshRates();
result= OrderSend(Symbol(),OP_SELL,Lots,Bid,3,SL,
sTP,"",mg,0,White); }
}
}
else
{ total=OrdersTotal();ChangeLot();
SelectData();
}
}
return(result);
}
//-----------------------------------------
// Ïðîôèò äëÿ äëèííûõ ïîçèöèé íà êîíâåðãåíöèè D1
//-----------------------------------------
double bProfit( double Adx)
{ double Level;
double Level1;
if (
CheckADX(1440,13,0,adx55step)==Up
|| MainTrend==Up)
{
Level=0;
return(0); }
else
{
//Åñëè äâèæåíèå íàèñõîäå, îãðàíè÷èâàåì Profit
if (CheckADX(1440,13,0,adx55step)==Down)
{Level1 = iMA(NULL,cMainFrame,55,0,MODE_EMA,PRICE_HIGH, 0 );
Level=Level1 + iMA(NULL,cMainFrame,55,0,MODE_EMA,PRICE_HIGH,1)-
iMA(NULL,cMainFrame,55,0,MODE_SMA,PRICE_HIGH, 10);
return(Level);
}
}
return(Level);
}
int MainLongOrder(double bTkP=0, int Mag=MainLongMagic)
{ datetime Begin=TimeCurrent();
double StL;
int magic, res, err;
res=-1;
if( total<OrderNum )
{
magic=Mag;
switch (magic)
{case MainLongMagic :
{if (lMainMagicNum>=MainOrderNum
|| lWeekMnMagicCnt>=1
) return;
else StL=iLow(NULL,cMainFrame,0)-StopLoss*Point;
}
break;
case LongMagic :
{if (lMagicNum>=LocalOrderNum
|| lDayMagicCnt>=1)return;
else StL=iLow(NULL,cMainFrame,0)-StopLoss*Point;
}
break;
case LongMagic1 :
{if (lMagicNum1>=LocalOrderNum1
|| lDaySmallMagicCnt>=1)return;
else StL=iLow(NULL,cMainFrame,0)-80*Point;
}
break;
case LongMagic2 :
{if (lMagicNum2>=LocalOrderNum1
|| lDaySmallMagic2Cnt>=1)return;
else StL=iLow(NULL,cMainFrame,0)-80*Point;
}
}
res= OrderSend(Symbol(),OP_BUY,Lots,Ask,3,StL,
bTkP,"",magic,0,Lime);
if (res<0)
{err=GetLastError();
Print("error(",err,"): ",ErrorDescription(err));
if(!IsTesting())
{while(!( res>0 || TimeCurrent()-Begin>20))
{Sleep(1000); RefreshRates();
res=OrderSend(Symbol(),OP_BUY,Lots,Ask,3,StL,
bTkP,"",magic,0,Lime);
}
}
}
else { total=OrdersTotal();ChangeLot(); SelectData(); }
}
return(res);
}
void SelectData()
{ double BullTop, BearTop, AdxD1,AdxD2;
Print("WaveNum=",WaveNum);
int Move=CheckADX(1440,13,1,2);
if (Move==Up) Print("ADX Up");
else
if (Move==Down) Print("ADX Down");
else
if (Move==Flat) Print("ADX Flat");
AdxD1= iADX(NULL,1440,13,PRICE_HIGH,MODE_MAIN,1);
AdxD2= iADX(NULL,1440,13,PRICE_HIGH,MODE_MAIN,2);
Print("AdxD1=",AdxD1," AdxD2=",AdxD2);
Print("sellADXDmax=",sellADXDmax);
BullTop=iBullsPower( NULL, dMainFrame, 13, PRICE_CLOSE, 0);
for (int i=1;i==10;i++)
{if(iBullsPower( NULL, dMainFrame, 13, PRICE_CLOSE, i)>BullTop)
BullTop=iBullsPower( NULL, dMainFrame, 13, PRICE_CLOSE, i);
}
BearTop=iBearsPower( NULL, dMainFrame, 13, PRICE_CLOSE, 0);
for ( i=1;i==10;i++)
{if(iBearsPower( NULL, dMainFrame, 13, PRICE_CLOSE, i)>BearTop)
BearTop=iBearsPower( NULL, dMainFrame, 13, PRICE_CLOSE, i);
}
if(WaitDn==Ready) Print("WaitDn=Ready");
else
if(WaitDn==NoSignal) Print("WaitDn=NoSignal");
else
if(WaitDn==Go) {Print("WaitDn=Go");
Print("Bid=", Bid);}
if(WaitUp==Ready) Print("WaitUp=Ready");
else
if(WaitUp==NoSignal) Print("WaitUp=NoSignal");
else
if(WaitUp==Go) {Print("WaitUp=Go");
Print("Ask=", Ask);}
Print("BullTop=",BullTop," BearTop=",BearTop);
if(WaitCorre==Ready) Print("WaitCorre=Ready");
else
if(WaitCorre==NoSignal) Print("WaitCorre=NoSignal");
else
if(WaitCorre==Go) {Print("WaitCorre=Go");
Print("Bid=", Bid);}
if(WaitCont==Ready) Print("WaitCont=Ready");
else
if(WaitCont==Go)
{Print("WaitCont=Go"); Print("Ask=", Ask); }
Print("");
Print("========================= New Data =======================================");
return;
}
void ChangeLot()
{ int histtotal=OrdersHistoryTotal();
if(histtotal>0)
{HPR=(AccountBalance()/(AccountBalance()-lastCloseProf));
SumHPR=SumHPR+HPR;
AHPR=(SumHPR)/histtotal;
}
if(lastCloseProf>0) Lots+=0.1;
if(lastCloseProf<0) Lots-=0.1;
if(Lots>5) Lots=5;
if(Lots<0.1) Lots=0.1;
}
void TestInstall()
{ if(TimeCurrent()<StrToTime("2006.10.10 00:00"))
{WaveNum=0;
WaitUp=NoSignal; WaitDn=NoSignal; WaitCorre=NoSignal;
MainTrend=Unknown;
LocalTrend=Unknown;
SmallTrend=Unknown;
WaitSmallUp=NoSignal;
WaitSmallDn=NoSignal;
WaitSmallCont=NoSignal;}
else
{ if( TimeCurrent()<StrToTime("2007.9.21 00:00"))
{MainTrend=Up;SetGlobVar("gMainTrend"+Symbol(),MainTrend);}
if(TimeCurrent()<StrToTime("2006.12.08 16:01"))
{LocalTrend=Up;SetGlobVar("gLocalTrend"+Symbol(),LocalTrend);
WaveNum=1;SetGlobVar("gWaveNum"+Symbol(),1);}
else
if(TimeCurrent()<StrToTime("2007.01.11 15:20"))
{LocalTrend=Down;SetGlobVar("gLocalTrend"+Symbol(),LocalTrend);
WaveNum=2;SetGlobVar("gWaveNum"+Symbol(),WaveNum);}
else
if(TimeCurrent()<StrToTime("2007.04.25 00:00"))
{LocalTrend=Up;SetGlobVar("gLocalTrend"+Symbol(),LocalTrend);
WaveNum=3;SetGlobVar("gWaveNum"+Symbol(),WaveNum);}
else
if(TimeCurrent()<StrToTime("2007.06.2 00:00"))
{LocalTrend=Down;SetGlobVar("gLocalTrend"+Symbol(),LocalTrend);
WaveNum=4;SetGlobVar("gWaveNum"+Symbol(),WaveNum);}
else
if(TimeCurrent()<StrToTime("2007.07.17 00:00"))
{LocalTrend=Up;SetGlobVar("gLocalTrend"+Symbol(),LocalTrend);
WaveNum=5;SetGlobVar("gWaveNum"+Symbol(),WaveNum);}
else
if(TimeCurrent()<StrToTime("2007.08.20 00:00"))
{LocalTrend=Down;SetGlobVar("gLocalTrend"+Symbol(),LocalTrend);
WaveNum=6;SetGlobVar("gWaveNum"+Symbol(),WaveNum);}
else
if(TimeCurrent()<StrToTime("2007.09.21 00:00"))
{LocalTrend=Up;SetGlobVar("gLocalTrend"+Symbol(),LocalTrend);
WaveNum=7;SetGlobVar("gWaveNum"+Symbol(),WaveNum);}
}
}
//+------------------------------------------------------------------+
//| expert initialization function |
//+------------------------------------------------------------------+
int init()
{ LastMainUpGoWeek=0;
LastMainDnGoWeek=0;
LastLocUpGoDay=0;
LastLocDnGoDay=0;
LastSmallUpDay=0;
LastSmallUpDay2=0;
LastSmallDnDay=0;
LastSmallDn2Day=0;
StartBalance=AccountBalance(); HPR=0; SumHPR=0;
AHPR=0; GHPR=0;
test1=true;
Gb=true;
if (!GlobalVariableCheck("gMainTrend"+Symbol()))
Gb= SetGlobVar("gMainTrend"+Symbol(),Unknown);
if (!GlobalVariableCheck("gLocalTrend"+Symbol()))
Gb= Gb && SetGlobVar("gLocalTrend"+Symbol(),Unknown);
if (!GlobalVariableCheck("gSmallTrend"+Symbol()))
Gb= Gb && SetGlobVar("gSmallTrend"+Symbol(),Unknown);
if (!GlobalVariableCheck("gWaitUp"+Symbol()))
Gb= Gb && SetGlobVar("gWaitUp"+Symbol(),NoSignal);
if (!GlobalVariableCheck("gWaitDn"+Symbol()))
Gb= Gb && SetGlobVar("gWaitDn"+Symbol(),NoSignal);
if (!GlobalVariableCheck("gWaitCorre"+Symbol()))
Gb= Gb && SetGlobVar("gWaitCorre"+Symbol(),NoSignal);
if (!GlobalVariableCheck("gWaitSmallUp"+Symbol()))
Gb= Gb && SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);
if (!GlobalVariableCheck("gWaitSmallDn"+Symbol()))
Gb= Gb && SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);
if (!GlobalVariableCheck("gWaitSmallCont"+Symbol()))
Gb= Gb && SetGlobVar("gWaitSmallCont"+Symbol(),NoSignal);
if (!GlobalVariableCheck("gWaveNum"+Symbol()))
Gb= Gb && SetGlobVar("gWaveNum"+Symbol(),0);
if (!GlobalVariableCheck("sWaitTime"+Symbol()))
Gb= Gb && SetGlobVar("sWaitTime"+Symbol(),0);
if (!GlobalVariableCheck("bWaitTime"+Symbol()))
Gb= Gb && SetGlobVar("bWaitTime"+Symbol(),0);
WaitCont=NoSignal;
if (! IsTesting())
{ MainTrend=GlobalVariableGet("gMainTrend"+Symbol());
LocalTrend=GlobalVariableGet("gLocalTrend"+Symbol());
WaitUp=GlobalVariableGet("gWaitUp"+Symbol());
WaitDn=GlobalVariableGet("gWaitDn"+Symbol());
WaitCorre=GlobalVariableGet("gWaitCorre"+Symbol());
WaitSmallUp=GlobalVariableGet("gWaitSmallUp"+Symbol());
WaitSmallDn=GlobalVariableGet("gWaitSmallDn"+Symbol());
WaitSmallCont=GlobalVariableGet("gWaitSmallCont"+Symbol());
sStartWaitingTime=GlobalVariableGet("sWaitTime"+Symbol());
bStartWaitingTime=GlobalVariableGet("bWaitTime"+Symbol());
} else
{WaveNum=0;
WaitUp=NoSignal; WaitDn=NoSignal; WaitCorre=NoSignal;
MainTrend=Unknown;
LocalTrend=Unknown;
SmallTrend=Unknown;
WaitSmallUp=NoSignal;
WaitSmallDn=NoSignal;
WaitSmallCont=NoSignal;
}
//----
AddpipsInit(Spips, Bpips);
PeriodInit(BearsP,BullsP);
OrderCount=OrdersTotal();
//----
return(0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{int histtotal=OrdersHistoryTotal();
if(histtotal>0)
{GHPR=MathPow(StartBalance/AccountBalance(),1/histtotal);
Print("AHPR=",AHPR," GHPR=",GHPR);
}
//----
return(0);
}
//+------------------------------------------------------------------+
//| expert start function |
//+------------------------------------------------------------------+
int start()
{if (!Gb)
{Print("Begin againe!!");
return(0);}
//MainTrend=trend;SetGlobVar("gMainTrend"+Symbol(),MainTrend);
//LocalTrend=trend;SetGlobVar("gMainTrend"+Symbol(),MainTrend);
int cnt;//ñ÷åò÷èê îðäåðîâ
int res; // ðåçóëüòàò óñòàíîâêì îðäåðà
int err,i,j;
int shift55; //ñäâèã íà H4 ñ ïåðèîäîì ADX 55
double maxAdx;
double Adx;
double StL; // StopLoss â ïóíêòàõ
double bTkP; // TakeProfit â ïóíêòàõ
double sTkP; // TakeProfit â ïóíêòàõ
int magic;
//----
if(Bars<BarsNum) return(0);
if (IsTesting() && test1)
{ TestInstall(); test1=false;}
MA100Vector=Up;
res=0;//âñïîìîãàòåëüíàÿ ïåðåì. äëÿ ñîõð. ðóçóëüòàòîâ óñòàíîâêè îðäåðîâ
total=OrdersTotal();
LastCloseParam();
OrdersMagic();
if (OrderCount<total)
OrderCount=total;
//Ãîòîâèìñÿ àíàëèçèðîâàòü ãðàôèê íà çàêðûòûõ áàðàõ
if (shift>0)
shift55=(shift-1)*6+1+TimeHour(TimeCurrent())/4;
else
shift55=0;
//==============================================================
// Äî òåõ ïîð ïîêà êîëè÷åñòâî ïèêîâ èíäèêàòîðà íà áóäåò ðàâíûì WaveTopNum
// èññëåäóåì ãðàôèê íà íàëè÷èå äèâåðãåíöèè ì-äó èíäèêàòîðì è High(Low)_
//Ïðîâåðÿåòñÿ äèâåðãåíöèÿ è-äó áàðîì 0 è 1 è åñëè äèâåðãåíöèè íåò,
// à áûêè íà áàðå 1 ñèëüíåå, òî áàð 1 ñòàíîâèòñÿ íà÷àëîì ïîèñêà äèâåðãåíöèè.
// Åñëè äèâåðãåíöèÿ åñòü - óâåëè÷èâàåì ñ÷åò÷èê äèâåðãåíöèé è ñîõðàíÿåì íîìåð åå áàðà.
// "Ïî ïóòè" íàõîäÿòñÿ ïèêè èíäèêàòîðà ñèëû áûêîâ(ìåäâåäåé). Íà íèõ ñ÷åò÷èê
//âîëí óâåëè÷èâàåòñÿ íà 1
// Òàê ïðîäîëæàåòñÿ äî òåõ ïîð, ïîêà íå îáíàðóæåíî òðè äèâåðãååíöèè (Div=3),
// èëè íå íàéäåíî WaveTopNum ïèêîâ èíäèêàòîðà.
//==============================================================
//-----------Ïðèíÿòèå ðåøåíèÿ ïî êîðîòêèì ïîçèöèÿì ------------
switch(WaitDn)
{//sw
case NoSignal :
{
sellADX=dStrongCond(dMainFrame,dADX0,0) ;
if ( sellADX>0 )
{ AddpipsInit(Spips, Bpips);
if ( SeachDiv(dMainFrame,dWaveTopNum,shift)
&& DiverKind(0, dMainFrame)
)
{
if ( CheckADX(240,55,shift,adx55step)==Down
&& maxADX(1440, 1, 30 )<81)
{//Print("sellADXDmax=",sellADXDmax);
WaitDn=Go; SetGlobVar("gWaitDn"+Symbol(), Go);
sStartWaitingTime = TimeCurrent();
}
else
{WaitDn=Ready; SetGlobVar("gWaitDn"+Symbol(), Ready);}
}// if Seach
}
}//case NoSignal
break;
case Ready :
{//case Ready
if (maxADX(1440, 1, 30 )<81)
{WaitDn=Go; sStartWaitingTime = TimeCurrent();SetGlobVar("sWaitTime"+Symbol(), sStartWaitingTime);
SetGlobVar("gWaitDn"+Symbol(), Go);
}
else
{WaitDn=TakeYourTime;SetGlobVar("gWaitDn"+Symbol(), TakeYourTime);
sStartTakeYourTime = TimeCurrent();}
}//case Ready
break;
case Go :
{//case Go
// Alert("Ïðîäàåì!");
MainShortOrder(OrderNum,MainShortMagic);
if(MainTrend!=Down)
{WaveNum=1;SetGlobVar("gWaveNum"+Symbol(),1);}
else if(TimeCurrent()- LastMainDnGoWeek>86400*40)
{WaveNum++;SetGlobVar("gWaveNum"+Symbol(),WaveNum);}//Wave counter
MainTrend=Down;
GlobalVariableSetOnCondition("gMainTrend"+Symbol(), Down, Up);
GlobalVariableSetOnCondition("gMainTrend"+Symbol(), Down, Flat);
LocalTrend=Down;GlobalVariableSet("gLocalTrend"+Symbol(),Down);
if((TimeCurrent()-sStartWaitingTime) > 864000 )
WaitDn=NoSignal; SetGlobVar("gWaitDn"+Symbol(),NoSignal);
sStartWaitingTime=NoSignal;SetGlobVar("sWaitTime"+Symbol(), sStartWaitingTime);
}//case Go
break;
case TakeYourTime :
{
if(iClose(NULL, cMainFrame,1)-iOpen(NULL, cMainFrame,1)<=0
|| MathAbs(iClose(NULL, cMainFrame,1)-iOpen(NULL, cMainFrame,1))<=15*Point)
{ WaitCorre=NoSignal; sellADXDmax=0; sStartTakeYourTime =0;
WaitDn=Go; sStartWaitingTime = TimeCurrent(); SetGlobVar("sWaitTime"+Symbol(), sStartWaitingTime);
SetGlobVar("gWaitDn"+Symbol(),Go);
SetGlobVar("gWaitCorre"+Symbol(),NoSignal);
}
}//TakeYourTime
break;
}//sw
//==========================================================
maxAdx=iADX(NULL,cMainFrame,13,PRICE_HIGH,MODE_MAIN,0);
if(((maxAdx>=58 && MainTrend==Up) //58
||
(maxAdx>27 && MainTrend==Down)
||
(maxAdx>25 && MainTrend==Flat)
)
&& CheckADX(1440,13,1,2)==Up
&& WaitCorre!=Go)
{
sellADXDmax=maxAdx; sellADXWmax=iADX(NULL,dMainFrame,13,PRICE_HIGH,MODE_MAIN,0);
WaitCorre=Ready;SetGlobVar("gWaitCorre"+Symbol(),Ready);
} else
{ //SelectData();
if( iBearsPower( NULL, 1440, 13, PRICE_CLOSE,3)<0 )
{WaitCorre=NoSignal;GlobalVariableSet("gWaitCorre"+Symbol(),NoSignal);}
}//else
if ( iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,1)
<iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,10)
&&
MathAbs(iBands(NULL,1440,100,2,0,PRICE_CLOSE,MODE_UPPER,0)-iHigh(NULL,1440,0))
<100*Point && WaitCorre==NoSignal
)
{WaitCorre=Ready;SetGlobVar("gWaitCorre"+Symbol(),Ready);}
if( iBearsPower( NULL, 1440, 13, PRICE_CLOSE,3)<0 && WaitCorre<NoSignal)
{WaitCorre=NoSignal;SetGlobVar("gWaitCorre"+Symbol(),NoSignal);}
if(WaitCorre<NoSignal )
{if(MainTrend==Up &&
iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,1)
>iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,10))
WaitCorre=sellSw(WaitCorre);
else WaitCorre=sellSw(WaitCorre,0);
SetGlobVar("gWaitCorre"+Symbol(),WaitCorre);
}
//==============Long================================
if(LocalTrend==Down)
{ double Bulls=BullDecline(1440, 32 );
double Bears=BearForce(1440, 32 );
if(MainTrend==Up && LocalTrend==Down
&& WaitUp==NoSignal
&& CheckADX(10080,13,1,5)==Up
&& dStrongCond(dMainFrame,dADX0,0)>0
)
if(
sellADXDmax>50
&& MathAbs(iMA(NULL,cMainFrame,21,0,MODE_EMA,PRICE_CLOSE,0)-
iClose(NULL,1440,0 ))<100*Point
)
{WaitUp=Go; SetGlobVar("gWaitUp"+Symbol(),Go); LongCall=0;
bStartWaitingTime =TimeCurrent(); SetGlobVar("bWaitTime"+Symbol(), bStartWaitingTime);}
if(((MainTrend!=Up && WaveNum==1) ||
(MainTrend==Up && (WaveNum==4 || WaveNum==6 || WaveNum==8)))
&& WaitUp>Ready && CheckiMa(1440, 100, MODE_SMA, 1, 40)== Up &&
MathAbs(iClose(NULL,1440,1)-
iIchimoku(NULL, dMainFrame, 9, 26, 52, MODE_KIJUNSEN, 1))<=50*Point)
{ if(Bears+Bulls>-0.06) {WaitUp=Ready;SetGlobVar("gWaitUp"+Symbol(),WaitUp);
bStartWaitingTime=TimeCurrent();SetGlobVar("bWaitTime"+Symbol(), bStartWaitingTime);
}
else {WaitSmallUp=Ready;SetGlobVar("gWaitSmallUp"+Symbol(),Ready);}
}
else
{ if((MainTrend==Up || (MainTrend==Flat && WaveNum==1)) && WaitUp==NoSignal
&&
MathAbs(iLow(NULL,1440,0 )-
iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,1))<=50*Point)
{if(MainTrend!=Flat)
{WaitUp=Ready;GlobalVariableSet("gWaitUp"+Symbol(),Ready); }
}
}
}
WaitUp=LongSwich( WaitUp, cADX0);
SetGlobVar("gWaitUp"+Symbol(),WaitUp);
//=== Äîáàâî÷íûå îðäåðà Buy
//+++++++++++++++++++++++++++++++++++++++++++
//1
if(LocalTrend==Down && MainTrend==Up)
{
if (iTime(NULL,cMainFrame,0)-LastLocDnGoDay>86400*3
&& iMFI(NULL, cMainFrame,7,0)>15 )
WaitSmallCont=buySw(WaitSmallCont,6,cMainFrame,cMainFrame);
}
//==========================================================
if(MainTrend!=Unknown && LocalTrend!=Unknown)
{
switch (WaitSmallUp)
{
case NoSignal :
{ if(LocalTrend==Up)
SmallBuyonUp();
}
break;
case Ready :
{ AddpipsInit(0, 5);WaitSmallDn=NoSignal; SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);
if ( SeachConv(240,cWaveTopNum,shift)
&& ConvKind(0, 240))
{WaitSmallUp=Go; SetGlobVar("gWaitSmallUp"+Symbol(),WaitSmallUp);}
else StopSmallBuyonUp();
AddpipsInit(Spips, Bpips);
}
break;
case Ready1 :
{ AddpipsInit(0, 0);WaitSmallDn=NoSignal; SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);
if ( SeachConv(60,cWaveTopNum,0)
&& ConvKind(0, 60))
{WaitSmallUp=Go; SetGlobVar("gWaitSmallUp"+Symbol(),Go);}
else StopSmallBuyonUp();
AddpipsInit(Spips, Bpips);
}
break;
}//sw
if(WaitSmallUp==Go)
//if(MainTrend==Up )
{ SmallTrend=Up;SetGlobVar("gSmallTrend"+Symbol(),Up);
StopSmallBuyonUp();
if ( AccountFreeMargin()/AccountBalance()>0.90)
{if(LocalTrend==Up) bTkP=Ask+250*Point;
else bTkP=Ask+180*Point;
if(WaitDn>Go && WaitCorre>Go)
MainLongOrder(bTkP,LongMagic2);
}
}
//++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++Small+++++++++++++++++++++
if(!(WaitDn==TakeYourTime || WaitDn==Ready))
switch (WaitSmallDn)
{case NoSignal :
{if(LocalTrend==Down)
SmallSellonDn();}
break;
case Ready :
{ AddpipsInit(10, 0); WaitSmallUp=NoSignal;SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);
SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);
StopSmallSellonDn();
if ( SeachDiv(240,cWaveTopNum,1) )
{//if(LocalTrend==Up)
//WaitSmallDn=Ready1;
//else
WaitSmallDn=Go;
SetGlobVar("gWaitSmallDn"+Symbol(),WaitSmallDn);
AddpipsInit(Spips, Bpips);}
else{AddpipsInit(Spips, Bpips);}
break;
}
case Ready1 :
{ AddpipsInit(10, 0); WaitSmallUp=NoSignal;
SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);
if ( (SeachDiv(60,cWaveTopNum,shift) && LocalTrend==Down)
||
(SeachDiv(60,cWaveTopNum,shift) && LocalTrend==Up && DiverKind(shift, 60))
//SeachDiv(60,cWaveTopNum,shift)
)
{WaitSmallDn=Go; SetGlobVar("gWaitSmallDn"+Symbol(),Go);
AddpipsInit(Spips, Bpips);}
else{AddpipsInit(Spips, Bpips); StopSmallSellonDn();
break;}
}
case Ready2 :
{ AddpipsInit(10, 0); WaitSmallUp=NoSignal;
SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);
if ( SeachDiv(1440,cWaveTopNum,shift)
&& DiverKind(0, 1440)
)
{WaitSmallDn=Go; SetGlobVar("gWaitSmallDn"+Symbol(),Go);
AddpipsInit(Spips, Bpips);}
else{AddpipsInit(Spips, Bpips); StopSmallSellonDn();
break;}
}
case Go :
{ if( (iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,1)>
iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,2)
&& iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,1)<10)
||
(LocalTrend==Up
&& iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,0)<50 )
)
{WaitSmallDn=NoSignal; SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);}
else
if(LocalTrend==Down && iBearsPower(NULL, 240, 13,PRICE_CLOSE,1)>0
)
{SmallTrend=Down;SetGlobVar("gSmallTrend"+Symbol(),Down);}
else if(LocalTrend==Up)
{SmallTrend=Down;SetGlobVar("gSmallTrend"+Symbol(),Down);}
}
break;
}
if (WaitSmallDn==Go)
{SmallTrend=Down; SetGlobVar("gSmallTrend"+Symbol(),Down);
if ( AccountFreeMargin()/AccountBalance()>0.90)
{ if (LocalTrend==Down) sTkP=Bid-200*Point; else sTkP=Bid-150*Point;
if(WaitUp>Go)
MainShortOrder(OrderNum,ShortMagic2,sTkP);}
if(iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,0)<35)
{WaitSmallDn=NoSignal;SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);}
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
}
if (WaitUp==NoSignal && WaitDn==NoSignal && WaitCorre!=Go
&& iADX(NULL,dMainFrame,13,PRICE_HIGH,MODE_MAIN,0)<65
)
{
if (
( iMA(NULL,dMainFrame,100,0,MODE_SMA,PRICE_CLOSE,1)>
iMA(NULL,dMainFrame,100,0,MODE_SMA,PRICE_CLOSE, 10 )
&&
iClose(NULL, 1440,1)>
iBands(NULL,1440,100,2,0,PRICE_CLOSE,MODE_UPPER,1)
&&
iClose(NULL, 1440,2)>
iBands(NULL,1440,100,2,0,PRICE_CLOSE,MODE_UPPER,2)
)
)
{if(CheckADX(1440,13,1,2)==Up && MainTrend!=Up)
{MainTrend=Up;GlobalVariableSet("gMainTrend"+Symbol(),Up); }
}
}
//---- Óñëîâèÿ çàêðûòèÿ, ìîäèôèêàöèè è óäàëåíèÿ îðäåðîâ------------
for(cnt=0;cnt<total;cnt++)
{//for
if( OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES)==true)
{//Seltct
if(OrderType()<=OP_SELL && // check for opened position
OrderSymbol()==Symbol()) // check for symbol
{//1
//--Îáðàáîòêà äëèííûõ ïîçèöèé ----------------
if(OrderType()==OP_BUY) // long position is opened
{//OP_BUY
//-----------------
if ( AccountFreeMargin()/AccountBalance()<Boundary)
{ res=OrderClose(OrderTicket(),OrderLots(),Bid,3,Gold); continue;}
if ( WaitDn==Go
||
(MainTrend==Down && OrderMagicNumber()==MainLongMagic)
)
res=OrderClose(OrderTicket(),OrderLots(),Bid,3,Aqua);
if ( LocalTrend==Down
&& (OrderMagicNumber()==LongMagic || OrderMagicNumber()==MainLongMagic)
)
res=OrderClose(OrderTicket(),OrderLots(),Bid,3,Aqua);
if ( (OrderMagicNumber()==LongMagic2 || OrderMagicNumber()==LongMagic1)
&& (SmallTrend==Down || WaitSmallDn==Go)
)
res=OrderClose(OrderTicket(),OrderLots(),Bid,3,Red);
//-----------------
}//OP_BUY
//--Êîíåö îáðàáîòêè äëèííûõ ïîçèöèé -----------
//--Îáðàáîòêà êîðîòêèõ ïîçèöèé ------------------
if(OrderType()==OP_SELL) // short position is opened
{//OP_SELL
//-----------------------------
if ( AccountFreeMargin()/AccountBalance()<Boundary)
{if(OrderMagicNumber()!=MainShortMagic)
res=OrderClose(OrderTicket(),OrderLots(),Ask,3,Gold); continue;
}
if ( OrderMagicNumber()==MainShortMagic && MainTrend==Up)
res=OrderClose(OrderTicket(),OrderLots(),Ask,3,Red);
if ( OrderMagicNumber()==ShortMagic && LocalTrend==Up)
res=OrderClose(OrderTicket(),OrderLots(),Ask,3,Red);
if ( //if
(//2
(TimeCurrent()-OrderOpenTime()>dMainFrame*Week*60)
&&
(TimeCurrent()-OrderOpenTime()<dMainFrame*(Week+2)*60)
&&
(iHigh(NULL,dMainFrame,Highest(NULL,dMainFrame,MODE_HIGH,Week+5,0))-
iLow(NULL,dMainFrame,Lowest(NULL,dMainFrame,MODE_LOW,Week,0)) )
<dMinTp*Point
&& OrderMagicNumber()==MainShortMagic
)//2
)//if
{res=OrderClose(OrderTicket(),OrderLots(),Ask,3,Aqua);
MainTrend=Flat;
GlobalVariableSetOnCondition("gMainTrend"+Symbol(),Flat ,Down);
}
if ( OrderMagicNumber()==MainShortMagic
&& MainTrend==Flat
&& iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)<20
&& SeachConv(240,dWaveTopNum,0)
)
res=OrderClose(OrderTicket(),OrderLots(),Ask,3,Red);
if ( OrderMagicNumber()==ShortMagic2
&& (SmallTrend==Up || WaitSmallUp==Go)
)
res=OrderClose(OrderTicket(),OrderLots(),Ask,3,Red);
}//OP_SELL
//--Êîíåö îáðàáîòêè êîðîòêèõ ïîçèöèé -----------
}
//Êîíåö óñëîâèé äëÿ îòêðûòûõ îðäåðîâ
}//Select
}//for ;
//---------------
//-------------------------------------------------------------------+
return(0);
//+------------------------------------------------------------------+
}
//+------------------------------------------------------------------+
int buySw(int Wait, int MFIperiod, int MFITimeFrame, int ConvTimeFrame)
{ int shf;
if( iMFI(NULL, MFITimeFrame,MFIperiod,0)>30 || WaitUp<NoSignal)
Wait=NoSignal;
switch (Wait)
{case NoSignal :
{ if(MFIperiod<7) shf=0; else shf=1;
if ( iMFI(NULL, MFITimeFrame,MFIperiod,shf)==0) Wait=Ready;
}
break;
case Ready :
{if( iMFI(NULL, MFITimeFrame,MFIperiod,0)>30 || WaitUp<NoSignal) Wait=NoSignal;
else
{if(MFIperiod<7) AddpipsInit(Spips, 5);
if (SeachConv(ConvTimeFrame,cWaveTopNum,shift)
&& ConvKind(shift, ConvTimeFrame)
)Wait= Go;
AddpipsInit(Spips, Bpips);
}
} break;
case Go :
{//SelectData();
if(MFIperiod==7)
{LocalTrend=Up;GlobalVariableSet("gLocalTrend"+Symbol(),Up);
MainLongOrder(0,LongMagic);}
if(MFIperiod<7)
{SmallTrend=Up; GlobalVariableSet("gSmallTrend"+Symbol(),Up);
double Tp=Ask+100*Point;
if(lMagicNum1==1)
Tp=0;
MainLongOrder(Tp,LongMagic1); }
}
break;
}
return(Wait);
}
//+++++++++++++++++++++++++++++++++
int sellSw(int WaitCorr, int StartBar=1)
{switch (WaitCorr)
{//sw
case NoSignal :
ShortCall=0;
break;
case Ready :
{ShortCall=0;
if (
CheckADX(1440,13,StartBar,StartBar+1)==Down
||
( CheckADX(240,55,1,14)==Down
&&
!(MainTrend==Up && iBullsPower( NULL, 1440, 100, PRICE_CLOSE, 0)>Bulls100)
//&& iADX(NULL,240,55,PRICE_HIGH,MODE_MAIN,1)>32
)
)
WaitCorr=Go;
}
break;
case Go :
{ AddpipsInit(10, 0);
if (SeachDiv(cMainFrame,dWaveTopNum,shift)
&& DiverKind(shift, cMainFrame)
)
DownCorrection();
else
if ((MainTrend==Down ||
iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,1)
<iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,10))
&&
TimeCurrent()-sStartCorreTime>86400*5 &&
SeachDiv(dSlaveFrame,dWaveTopNum,shift)
&& DiverKind(shift, dSlaveFrame) )
DownCorrection();
AddpipsInit(Spips, Bpips);
}
break;
}//sw WaitCorr
return(WaitCorr);
}
void DownCorrection(int Frame=1440)
{ double TP;
if(iMA(NULL,Frame,100,0,MODE_SMA,PRICE_CLOSE,1)
>iMA(NULL,cMainFrame,100,0,MODE_SMA,PRICE_CLOSE,10))
{ if( sellADXDmax>75 && MainTrend==Up)
TP=iMA(NULL,cMainFrame,21,0,MODE_EMA,PRICE_CLOSE,0)+20*Point;
else
TP=iIchimoku(NULL, dMainFrame, 9, 26, 52, MODE_KIJUNSEN, 0);
}
else
TP= 0;
//TP= ( iHigh(NULL,cMainFrame,1) +
// iLow(NULL,dMainFrame,iLowest(NULL,dMainFrame,MODE_LOW,12,1)))/2.2;
ShortCall++;
if(ShortCall==1)
{
if(MainTrend==Up
)
WaveNum+=1;
else
if(MainTrend==Down
&& TimeCurrent()- LastLocDnGoDay>86400*30
&& TimeCurrent()- LastMainDnGoWeek>86400*30)
WaveNum+=1;//Wave counter
SetGlobVar("gWaveNum"+Symbol(),WaveNum);
LocalTrend=Down;GlobalVariableSet("gLocalTrend"+Symbol(),Down);
}
if(AccountFreeMargin()/AccountBalance()>0.80)
MainShortOrder(OrderNum,ShortMagic, TP);
}
//-----------------------------------------------------------
int LongSwich(int Wait, double ADX, int magicnum=MainLongMagic, int DayCnt=10 )
{int magic, ret, lastTrend;
double bTkP;
switch(Wait)
{//sw
case NoSignal :
{LongCall=0;
buyADX= cMidlCond(cMainFrame,PRICE_HIGH, ADX, shift );
if ( buyADX>0 )
{
if ( SeachConv(cMainFrame,cWaveTopNum,shift)
&& ConvKind(shift, cMainFrame)
)
{ if (CheckADX(240,55,0,adx55step/2)==Down
&& iBearsPower( NULL, cSlaveFrame, 13, PRICE_CLOSE,1)>W1MinBears)
{Wait=Go; bStartWaitingTime =TimeCurrent();SetGlobVar("bWaitTime"+Symbol(), bStartWaitingTime);}
else
Wait=Ready;
}
}
}//case 0
break;
case Ready :
{//case Ready :
LongCall=0;
if (CheckADX(240,55,0,adx55step/2)==Down
&& iBearsPower( NULL, cSlaveFrame, 13, PRICE_CLOSE,1)>W1MinBears)
{ Wait=Go; bStartWaitingTime = TimeCurrent();SetGlobVar("bWaitTime"+Symbol(), bStartWaitingTime);
}
}//case Ready
break;
case Go :
{//case 2 :
AddpipsInit(Spips, 15 );
if ( ( SeachConv(cMainFrame,cWaveTopNum,0)
&& ConvKind(0, cMainFrame))
||
(SeachConv(dMainFrame,cWaveTopNum,0)
&& ConvKind(0, dMainFrame))
)
{lastTrend=MainTrend; LongCall++;
LocalTrend=Up;GlobalVariableSet("gLocalTrend"+Symbol(),Up);
AddpipsInit(Spips, Bpips);
{ bTkP=bProfit(buyADX);
if (bTkP==0)
{magic=MainLongMagic;MainTrend=Up;GlobalVariableSet("gMainTrend"+Symbol(),Up);
if(LongCall==1){
if(lMainMagicNum==0 && lastTrend!=Up)WaveNum=1;
else if(lWeekMnMagicCnt==0 && lastTrend==Up && TimeCurrent()- LastMainUpGoWeek>86400*30)
WaveNum++;}
}
else
{ magic=LongMagic;
if(LongCall==1 && (TimeCurrent()- LastLocUpGoDay>86400*30))WaveNum++;
}
GlobalVariableSet("gWaveNum"+Symbol(),WaveNum);
if( AccountFreeMargin()/AccountBalance()>0.9)
{ret=MainLongOrder(bTkP,magic);
}
}
}
if((TimeCurrent()-bStartWaitingTime) > 86400*DayCnt )
{
Wait=NoSignal; bStartWaitingTime=NoSignal;SetGlobVar("bWaitTime"+Symbol(), bStartWaitingTime);
}
}//case Go
break;
}//sw
return(Wait);
}
//==========================================================
void StopSmallBuyonUp()
{
if((WaitCorre!=NoSignal && iBullsPower( NULL, 1440, 100, PRICE_CLOSE, 0)<Bulls100)
||WaitDn==Go)
RotUpWaitSmall();
else
{ if (!(MainTrend==Up && iBullsPower( NULL, 1440, 100, PRICE_CLOSE, 0)>Bulls100))
{
if(iMA(NULL,240,100,0,MODE_SMA,PRICE_CLOSE,1)-
iMA(NULL,240,100,0,MODE_SMA,PRICE_CLOSE,5)
<5*Point
&&
iMA(NULL,240,5,0,MODE_SMA,PRICE_CLOSE,1)-
iMA(NULL,240,5,0,MODE_SMA,PRICE_CLOSE,11)
<80*Point
)
{ if(iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)>80
&&
iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,0)>75
)
{ WaitSmallDn=Ready2;
SetGlobVar("gWaitSmallDn"+Symbol(),Ready2);
WaitSmallUp=NoSignal;
SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal); }
}//iMa>
else
if(iMA(NULL,240,21,0,MODE_SMA,PRICE_CLOSE,0)-
iMA(NULL,240,21,0,MODE_SMA,PRICE_CLOSE,6)
<45*Point
)
{if(minStoch(240, 1, 4 )>87
&&
iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,1)<=
iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_SIGNAL,1)
)
RotUpWaitSmall();
}
else
Rot1WaitSmall();
}
else
if ( MainTrend==Up && iBullsPower( NULL, 1440, 100, PRICE_CLOSE, 0)>Bulls100
)
if(CheckiMa(60, 21, MODE_SMA, 1, 10)== Up)
{WaitSmallUp=NoSignal;
SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);}
}
}
//===========================================================
void SmallBuyonUp()
{
if ( MainTrend==Up && iBullsPower( NULL, 1440, 100, PRICE_CLOSE, 0)>Bulls100)
{if(CheckiMa(60, 21, MODE_SMA, 1, 10)== Down)
Rot1UpWaitSmall();
else
{WaitSmallUp=NoSignal;
SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);}
}
else
{if(iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,0)>=
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_SIGNAL,0)
&&
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)>
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,2)
&&
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)<25
&&
iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,0)<82
)
Rot1WaitSmall();
else
StopSmallBuyonUp();
}
}
//===========================================================
void StopSmallSellonDn()
{ switch (MainTrend)
{//sw
case Flat:
{ if(iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,0)>=
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_SIGNAL,0)
&&
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)>
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,2)
&&
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)<25
&&
iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,2)<80
)
Rot1WaitSmall();
}
break;
default :
{if((MainTrend==Down && LocalTrend==Down &&
CheckiMa(1440, 100, MODE_SMA, 1, 10)== Down ))
{ if(CheckiMa(60, 21, MODE_SMA, 1, 10)== Up )
{WaitSmallDn=NoSignal;
SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);
} else RotDnWaitSmall();
}
else
if(MainTrend==Down && LocalTrend==Down &&
CheckiMa(1440, 100, MODE_SMA, 1, 10)== Up
&& iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,0)<25)
{WaitSmallDn=NoSignal;
SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);
}
else
if(!( iMA(NULL,240,21,0,MODE_EMA,PRICE_CLOSE,21)-
iMA(NULL,240,21,0,MODE_EMA,PRICE_CLOSE,1)>=90*Point)
)
{
if( iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,1)<=MaxStStopSellonDn//25!
&&
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)<25
&&
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)>=
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,2)
)
Rot1WaitSmall();
}
else
{if( iRSI(NULL,1440,14,PRICE_CLOSE,1)<=33
&&
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)<20
&&
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)>
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,2) )
Rot1WaitSmall();
}
}
break;
}//sw
}
//==============================================================
void SmallSellonDn()
{
if(LocalTrend==Down)
{//1
if(CheckiMa(240, 100, MODE_SMA, 1, 24)== Down
&& SmallTrend==Down
&& WaitUp>Ready )
{//2
if(iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,0)<
iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,1)
&&
iStochastic(NULL,60,8,3,3,MODE_SMA,0,MODE_MAIN,0)<
iStochastic(NULL,60,8,3,3,MODE_SMA,0,MODE_MAIN,1)
&&
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,0)>22
&&
iStochastic(NULL,60,8,3,3,MODE_SMA,0,MODE_MAIN,1)>60
&&
iStochastic(NULL,60,8,3,3,MODE_SMA,0,MODE_MAIN,0)<=
iStochastic(NULL,60,8,3,3,MODE_SMA,0,MODE_SIGNAL,0)
)
RotDnWaitSmall();
}//2
else
if(iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,0)<=
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_SIGNAL,0)
&&
iStochastic(NULL,240,8,3,3,MODE_SMA,0,MODE_MAIN,1)>60
&&
iStochastic(NULL,1440,8,3,3,MODE_SMA,0,MODE_MAIN,1)>MinStSellonDn
)
RotWaitSmall();
else
StopSmallSellonDn();
}//1
}
//----------------------------------------------
void RotWaitSmall()
{WaitSmallDn=Ready;
SetGlobVar("gWaitSmallDn"+Symbol(),Ready);
WaitSmallUp=NoSignal;
SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);
}
//----------------------------------------------
void Rot1WaitSmall()
{WaitSmallUp=Ready;
SetGlobVar("gWaitSmallUp"+Symbol(),Ready);
WaitSmallDn=NoSignal;
SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);
}
void RotDnWaitSmall()
{WaitSmallDn=Ready1;
SetGlobVar("gWaitSmallDn"+Symbol(),Ready1);
WaitSmallUp=NoSignal;
SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal);
}
void RotUpWaitSmall()
{WaitSmallDn=Ready2;
SetGlobVar("gWaitSmallDn"+Symbol(),Ready2);
WaitSmallUp=NoSignal;
SetGlobVar("gWaitSmallUp"+Symbol(),NoSignal); }
void Rot1UpWaitSmall()
{WaitSmallUp=Ready1;
SetGlobVar("gWaitSmallUp"+Symbol(),Ready1);
WaitSmallDn=NoSignal;
SetGlobVar("gWaitSmallDn"+Symbol(),NoSignal);
}
Sample
Analysis
Market Information Used:
Series array that contains the highest prices of each bar
Series array that contains the lowest prices of each bar
Series array that contains open prices of each bar
Series array that contains close prices for each bar
Indicator Curves created:
Indicators Used:
Moving average indicator
Ichimoku Kinko Hyo
Movement directional index
Stochastic oscillator
Bears Power indicator
Bulls Power indicator
Bollinger bands indicator
Money flow index
Relative strength index
Custom Indicators Used:
Diver
Order Management characteristics:
Checks for the total of closed orders
It can change open orders parameters, due to possible stepping strategy
Checks for the total of open orders
It Closes Orders by itself
Other Features: