//+------------------------------------------------------------------+
//| expert.mq4 |
//| Denis Janulis |
//| denis.j@mits.lv |
//+------------------------------------------------------------------+
#property copyright "Denis Janulis"
#property link "denis.j@mits.lv"
#import "dpnn.dll" // DPNN.DLL - ïîäêëþ÷àåì ñåòü
//--------------------------------------------------------------------
extern double MinW = 0.00100200; // êðèòåðèé ñëàáîñòè íåéðîíîâ. Åñëè 0, òî æèâóò âå÷íî
extern double LifeTime = 500; // âðåìÿ æèçíè íåéðîíîâ (â áàðàõ). Åñëè 0, òî æèâóò âå÷íî
extern double MinTV = 0.2; // Ïîðîã êîíôëèêòîâ
extern double MaxTV = 0.95; // Ïîðîã èíäèâèäóàëüíîñòè
//--------------------------------------------------------------------
// Îñíîâíûå íåîáõîäèìûå ôóíêöèè ðàáîòû ñ ñåòüþ
double CreateNet(string NN, int InputVectorSize, // Ñîçäàåò ñåòü ñ êîëè÷åñòâîì íåéðîíîâ âî âõîäíîì âåêòîðå <i>.
double MinTV, double MaxTV, // è âîçâðàùàåò íîìåð ñåòè, ïîä êîòîðûì ñîçäàëàñü
double MW , int NL);
int DestroyNet(string NN); // Óíè÷òîæàåò ñåòü <NetName>, âîçâðàùàåò êîëè÷åñòâî îñòàâøèõñÿ ñåòåé
double TrainNet(string NetName,double& iX[],int T,datetime sT); // Îáó÷àåò ñåòü íà ïðèìåðå Õ[InputVectorSize] c îòâåòîì Ò
double GetPredict(string NetName,double& iX[],datetime sT); // Âîçâðàùàåò ïðåäñêàçàíèå ñåòè 0<=Out<=1
void Shrink(string NetName); // ÏÎÊÀ ÓÏÐÀÂËßÅÒÑß ÂÐÓ×ÍÓÞ!!! - íàäî çàïóñêàòü ïîñëå îáó÷åíèÿ
void WReset(string NetName); // (A) - ÏÎÊÀ ÓÏÐÀÂËßÅÒÑß ÂÐÓ×ÍÓÞ!!! - íàäî çàïóñêàòü ïîñëå îáó÷åíèÿ
void AEqual(string NetName); // (A) - ÏÎÊÀ ÓÏÐÀÂËßÅÒÑß ÂÐÓ×ÍÓÞ!!! - íàäî çàïóñêàòü ïîñëå îáó÷åíèÿ
void CW(string NetName); // (w) - ÏÎÊÀ ÓÏÐÀÂËßÅÒÑß ÂÐÓ×ÍÓÞ!!! - íàäî çàïóñêàòü ïîñëå îáó÷åíèÿ
int SizeOfNet(string NetName); // Âîçâðàùàåò êîëè÷åñâî Ãàóññîâñêèõ íåéðîíîâ
void KillWeaks(string NetName);
void KillOlds(string NetName,datetime sT);
//-------------------------------------------------------------------
int InputVectorSize = 24; // Ðàçìåðíîñòü âõîäíîãî âåêòîðà
double X[24]; // Âõîäíîé âåêòîð ñåòè
//-------------------------------------------------------------------
extern int n = 10; // Ïàðàìåòðû äëÿ "ó÷èòåëÿ" ñì. èíäèêàòîð djama
extern int p = 2;
extern int q = 2;
extern bool allowTrailingStop = true; // Ðàçðåøàåì òðàëû
extern bool allowPostTraining = true; // Ðàçðåøàåì äîîáó÷åíèå
extern int StopLoss = 50;
extern int TakeProfit = 400;
extern int TrailingStop = 150;
extern int HistoryBars = 1000; // Íà ñêîëüêèõ áàðàõ ïðîâîäèòü ïðåäâàðèòåëüíîå îáó÷åíèå
extern int Repetitions = 5; // Ñêîëüêî ðàç ïðîãíÿòü îáó÷åíèå ñåòè ????
extern int Activation_n = 100; // Ïàðàìåòðû äëÿ "àêòèâàöèîííîé ôóíêéèè" ñì. èíäèêàòîð djama
extern int Activation_p = 2;
extern int Activation_q = 30;
extern double ActivationMax = 0.95;
extern double ActivationMin = 0.6;
extern double ActivationK = 15000;
double ActivationBuy;
double ActivationSell;
//--------------------------------------------------------------------
double Lots = 0.1;
int MinMargin = 200; // Ìèíèìàëüíàÿ ìàðæà
datetime prevtime = 0;
double Out; // Ðåçóëüòàò ðàáîòû ñåòåé
bool existent = false;
//********************************************************************
void BuildX(int FinishBar) // Ìîäóëü ñîáèðàåò è ïîäãîòàâëèâàåò äàííûå äëÿ çàãðóçêè â ñåòü
{ // FinishBar - Ñ êàêîãî áàðà ñíèìàòü çíà÷åíèÿ.
int B = InputVectorSize;
double rD[24][24];
double Min[24];
double Max[24];
if (FinishBar > Bars)
{
Print("MaxBars Error = ",Bars);
return;
}
for (int i=B-1;i>=0;i--)
{
rD[i][0] = iMA(NULL,0,2,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,2,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][1] = iMA(NULL,0,4,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,4,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][2] = iMA(NULL,0,6,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,6,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][3] = iMA(NULL,0,8,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,8,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][4] = iMA(NULL,0,10,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,10,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][5] = iMA(NULL,0,12,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,12,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][6] = iMA(NULL,0,14,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,14,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][7] = iMA(NULL,0,16,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,16,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][8] = iMA(NULL,0,18,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,18,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][9] = iMA(NULL,0,20,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,20,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][10] = iMA(NULL,0,22,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,22,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][11] = iMA(NULL,0,24,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,24,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][12] = iMA(NULL,0,26,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,26,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][13] = iMA(NULL,0,28,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,28,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][14] = iMA(NULL,0,30,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,30,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][15] = iMA(NULL,0,32,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,32,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][16] = iMA(NULL,0,34,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,34,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][17] = iMA(NULL,0,36,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,36,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][18] = iMA(NULL,0,38,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,38,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][19] = iMA(NULL,0,40,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,40,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][20] = iMA(NULL,0,42,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,42,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][21] = iMA(NULL,0,44,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,44,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][22] = iMA(NULL,0,46,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,46,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
rD[i][23] = iMA(NULL,0,48,0,MODE_EMA,PRICE_WEIGHTED,i+FinishBar)-iMA(NULL,0,48,0,MODE_EMA,PRICE_WEIGHTED,i+1+FinishBar);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
for (int n = 0; n <= B-1; n++) // Îïðåäåëÿåì ìèíèìàëüíûå è ìàêñèìàëüíûå âåëè÷èíû
{
Min[n] = rD[0][n];
Max[n] = rD[0][n];
for ( i = 0; i <= B-1; i++)
{
if (rD[i][n] > Max[n]) Max[n] = rD[i][n];
if (rD[i][n] < Min[n]) Min[n] = rD[i][n];
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
for ( n = 0; n <= B-1; n++) // Íîðìèðóåò âõîäíîé âåêòîð íà 1
{
if (Max[n]== Min[n])
{
for ( i = 0; i <= B-1; i++) X[i] = Max[n];
return;
}
X[n] = (rD[0][n] - Min[n])/(Max[n]-Min[n]); // Âõîäíîé âåêòîð, íîðìèðîâàííûé íà 1
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
return;
}
//-------------------------------------------------------------------------------------------------------------------
int BuildT(int i) // Òóò ïîëó÷àåì ïðàâèëüíûé îòâåò ïî ïåðåêóïëåííîñòè
{ // èëè ïåðåïðîäàííîñòè
int T= 0;
double Previous = djama(n,p,q,i+1);
double Current = djama(n,p,q,i);
double Next = djama(n,p,q,i-1);
if ((Current > Previous) && (Current > Next)) T = -1;
if ((Current < Previous) && (Current < Next)) T = 1;
return (T);
}
//*******************************************************************************************************************
int Create(string NetName,int InputVectorSize) // Ñîçäàåò ñåòü ñ èìåíåì <NetName> è âõîäíûì âåêòîðîì ðàçìåðà
{ // InputVectorSize. Âûâîäèò íîìåð ñåòè (òóò îí æå îáùåå êîëè÷åñòâî
int NeuronLife = Period()*60*LifeTime; // ñåòåé) â áèáëèîòåêå.
int Out = CreateNet(NetName,InputVectorSize,MinTV,MaxTV,MinW,NeuronLife);
return(Out);
}
//-------------------------------------------------------------------------------------------------------------------
int Destroy(string NetName) // Óíè÷òîæàåò ñåòü ñ èìåíåì <NetName> è âîçâðàùàåò îáùåå
{ // êîëè÷åñòâî ñåòåé îñòàâøèõñÿ â áèáëèîòåêå
return(DestroyNet(NetName));
}
//-------------------------------------------------------------------------------------------------------------------
double Train(string NetName,double& iX[],int T) // Ïîäàåò â ñåòü <NetName> âåêòîð X è îòâåò T äëÿ îáó÷åíèÿ íà ïðèìåðå i
{ // Âîçâðàùàåò Out cåòè
double Out = TrainNet(NetName,iX,T,iTime(Symbol(),0,1)); // Out=1, ñåòü äîáàâèëà íîâûé îáðàç. Out =2 - ñåòü ðàñïîçíàëà îáðàç è ïîäïðàâèëàñü.
return(Out);
}
//-------------------------------------------------------------------------------------------------------------------
double Predict(string NetName) // Ïîäàåò â ñåòü <NetName> âåòîð X äëÿ ïðåäñêàçàíèÿ
{
BuildX(1);
double Out = GetPredict(NetName,X,iTime(Symbol(),0,1)); // Âîçâðàùàåò Out cåòè
return(Out);
}
//--------------------------------------------------------------------------------------------------------------------
double PostTraining(string NetName,int ST)
{
int T = BuildT(2); // Ñ÷èòûâàåì ïðàâèëüíûé îòâåò
if (T == ST) // Îáó÷àåì òîëüêî íà òîì ïðèìåðå, êîòîðûé ïîäõîäèò äëÿ îáó÷åíèÿ
{
BuildX(2); // Ôîðìèðóåì âõîäíîé îáó÷àþùèé âåêòîð
Train(NetName,X,T); // Îáó÷àåì ñåòü íà êîíêðåòíîì ïðèìåðå
Print("New neurons amount: ",SizeOfNet("OverBought")," ; ",SizeOfNet("OverSold"));
}
return (0);
}
//-------------------------------------------------------------------------------------------------------------------
double InitialTraining(string NetName,int HistoryBars,int ST) // Ðóêîâîäèò çàãðóçêîé äàííûõ â ñåòü äëÿ ïåðâè÷íîãî îáó÷åíèÿ
{ // çà ïåðèîä HistoryBars
for ( int i = HistoryBars-1; i > 6; i--) // ïî áàðàì
{
int T = BuildT(i); // Ñ÷èòûâàåì ïðàâèëüíûé îòâåò
if (T == ST) // Îáó÷àåì òîëüêî íà òîì ïðèìåðå, êîòîðûé ïîäõîäèò äëÿ îáó÷åíèÿ
{
BuildX(i); // Ôîðìèðóåì âõîäíîé îáó÷àþùèé âåêòîð
Train(NetName,X,T); // Îáó÷àåì ñåòü íà êîíêðåòíîì ïðèìåðå
}
}
return (0);
}
//-------------------------------------------------------------------------------------------------------------------
int init()
{
NetInitialTraining();
}
//********************************************************************
int start()
{
if (AccountFreeMargin() < MinMargin) return(0);
if(prevtime == Time[0]) return(0);
prevtime = Time[0];
//-------------------------------------------------------------------
if (allowPostTraining)
{
if (LifeTime > 0) KillOlds("OverBought",iTime(Symbol(),0,1)); // Óáèâàåì ñòàðûå íåéðîíû
PostTraining("OverBought",-1); // Äîîáó÷àåì ïî õîäó äåëà
Shrink("OverBought"); // Ìîäåðíèçèðóåì ñåòü
//AEqual("OverBought"); // Óñòàíàâëèâàåì âñå A =1
CW("OverBought"); // Ðàññ÷èòûâàåì âåñà
KillWeaks("OverBought"); // Óáèâàåì ñëàáûå íåéðîíû
CW("OverBought"); // Ðàññ÷èòûâàåì âåñà
if (LifeTime > 0) KillOlds("OverSold",iTime(Symbol(),0,1)); // Óáèâàåì ñòàðûå íåéðîíû
PostTraining("OverSold",1); // Äîîáó÷àåì ïî õîäó äåëà
//AEqual("OverSold"); // Óñòàíàâëèâàåì âñå A =1
Shrink("OverSold"); // Ìîäåðíèçèðóåì ñåòü
CW("OverSold"); // Ðàññ÷èòûâàåì âåñà
KillWeaks("OverSold"); // Óáèâàåì ñëàáûå íåéðîíû
CW("OverSold"); // Ðàññ÷èòûâàåì âåñà
}
//--------------------------------------------------------------------
double OverBought = Predict("OverBought");
double OverSold = Predict("OverSold");
Out = (OverBought - OverSold)/(OverBought+OverSold);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Activation(1);
CheckForClose();
if (allowTrailingStop) CheckForTrailingStop();
CheckForOpen();
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
return(0);
}
//+------------------------------------------------------------------+
int deinit()
{
if (!IsOptimization())
{
Print("Destroying net=>",Destroy ("OverBought")); // Óáèâàåì, ÷òî ïîðîäèëè
Print("Destroying net=>",Destroy ("OverSold")); // Óáèâàåì, ÷òî ïîðîäèëè
}
}
//-------------------------------------------------------------------------------------
void CheckForOpen()
{
double SL = 0;
double TP = 0;
//-----------------------------------------
if ( Out < (-1)*ActivationBuy)
{
SL = Ask - StopLoss*Point;
TP = Ask + TakeProfit*Point;
OpenPosition(0,SL,TP,0);
Print("OverSoldSignal= ",Out);
}
//-----------------------------------------
if (Out > ActivationSell)
{
SL = Bid + StopLoss*Point;
TP = Bid - TakeProfit*Point;
OpenPosition(1,SL,TP,1);
Print("OutBoughtSignal= ",Out);
}
//-----------------------------------------
return(0);
}
///////////////////////////////////////////////////////////////////////////////
void CheckForClose()
{
if (Out < (-1)*ActivationBuy) ClosePosition(1);
if (Out > ActivationSell) ClosePosition(0);
return(0);
}
//------------------------------------------
double Activation(int i )
{
double t = (djama(Activation_n,Activation_p,Activation_q,i)-djama(Activation_n,Activation_p,Activation_q,i+Activation_n))/Activation_n;
//~~~~ActivationBuy
double M = (ActivationMin-ActivationMax)/(-ActivationK);
if (t <= 0) ActivationBuy = ActivationMax;
if (t >= M) ActivationBuy = ActivationMin;
if ((t > 0) && (t < M)) ActivationBuy = -ActivationK*t+ActivationMax;
//~~~~ActivationSell
M = (ActivationMin-ActivationMax)/(-ActivationK);
if (t >= 0) ActivationSell = ActivationMax;
if (t <= -M) ActivationSell = ActivationMin;
if ((t < 0) && (t > -M)) ActivationSell = ActivationK*t+ActivationMax;
return(t);
}
//-------------------------------------------
void NetInitialTraining()
{
int Size0 = 0;
int Size1 = 0;
Print("Net Created with number: ",Create("OverBought",24)); // Ñîçäàåì ñåòü äëÿ ñèãíàëîâ Sell
Print("Net Created with number: ",Create("OverSold",24)); // Ñîçäàåì ñåòü äëÿ ñèãíàëîâ Buy
//~~
Print("Initial training started ...");
for (int R = 1; R <= Repetitions; R++) // Ïðîöåññ ïåðâè÷íîãî îáó÷åíèÿ
{ // íà èñòîðè÷åñêèõ äàííûõ
WReset("OverBought"); // Îáíóëÿåì çíà÷åíèÿ À
InitialTraining("OverBought",HistoryBars,-1); // Ïðîãîíÿåì îáó÷åíèå
Shrink("OverBought"); // Ìîäåðíèçèðóåì ñåòü
AEqual("OverBought"); // Óñòàíàâëèâàåì âñå A =1
CW("OverBought"); // Ðàññ÷èòûâàåì âåñà
KillWeaks("OverBought"); // Óáèâàåì ñëàáûå íåéðîíû
CW("OverBought"); // Ðàññ÷èòûâàåì âåñà
WReset("OverSold"); // Îáíóëÿåì çíà÷åíèÿ À
InitialTraining("OverSold",HistoryBars,1); // Ïðîãîíÿåì îáó÷åíèå
AEqual("OverSold"); // Óñòàíàâëèâàåì âñå A =1
Shrink("OverSold"); // Ìîäåðíèçèðóåì ñåòü
CW("OverSold"); // Ðàññ÷èòûâàåì âåñà
KillWeaks("OverSold"); // Óáèâàåì ñëàáûå íåéðîíû
CW("OverSold"); // Ðàññ÷èòûâàåì âåñà
Print("Cycle ",R," completed. Neurons: ",SizeOfNet("OverBought")," ; ",SizeOfNet("OverSold"));
if ((SizeOfNet("OverBought") == Size0) && (SizeOfNet("OverSold") == Size1)) break;
Size0 = SizeOfNet("OverBought");
Size1 = SizeOfNet("OverSold");
}
Print("Initial training completed.");
}
//-------------------------------------------------------------+
double djama(int n, int p, int q, int i)
{
return(iCustom(Symbol(),0,"djama",n,p,q,0,i));
}
//-------------------------------------------------------------+
bool OpenPosition(int cmd, double SL, double TP,int MN)
{
bool OpenPosition = false;
static int MaxTries = 5;
static int OrderInterval = 10;
static int ticket = 0;
if (Positions(0,MN) >= 1 || Positions(1,MN) >= 1) return;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
double Lots = 0.1;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
for (int try=1;try<=MaxTries;try++)
{
switch(cmd)
{
case 0 : ticket=OrderSend(Symbol(),cmd,Lots,NormalizeDouble(Ask,4),5,NormalizeDouble(SL,4),NormalizeDouble(TP,4),DoubleToStr(MN,0),MN,Blue); break; // OP_BUY
case 1 : ticket=OrderSend(Symbol(),cmd,Lots,NormalizeDouble(Bid,4),5,NormalizeDouble(SL,4),NormalizeDouble(TP,4),DoubleToStr(MN,0),MN,Red); break; // OP_SELL
}
if (ticket>0)
{
OpenPosition = true;
Print("Opened ",cmd," try N",try," SL ",SL," TP ",TP, " Magic Number: ", MN);
break;
}
Sleep(10000);
Print("Cannot open ",cmd," try N",try," SL ",SL," TP ",TP);
}
return(OpenPosition);
}
//*******************************************************************
bool ClosePosition(int p)
{
bool ClosePosition;
int MaxTries = 5;
for(int i=0;i<OrdersTotal();i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
if((OrderSymbol()!=Symbol()) || (OrderType() != p)) continue;
for (int try=1;try<=5;try++)
{
if ((p == 0) && (OrderType()==OP_BUY)) ClosePosition = OrderClose(OrderTicket(),OrderLots(),Bid,3,Black);
if ((p == 1) && (OrderType()==OP_SELL)) ClosePosition = OrderClose(OrderTicket(),OrderLots(),Ask,3,Black);
if (ClosePosition == true)
{
if ( p == 0) Print("Position :",OrderTicket(), "closed at ",Bid," MN ",OrderMagicNumber());
if ( p == 1) Print("Position :",OrderTicket(), "closed at ",Ask," MN ",OrderMagicNumber());
break;
}
if ( p == 0) Print("Cannot close long position at price, try N ",try," => Bid = ",Bid," ERROR = ",GetLastError());
if ( p == 1) Print("Cannot close short position at price, try N ",try," => Ask = ",Ask," ERROR = ",GetLastError());
Sleep(10000);
} // try
} //i
return(ClosePosition);
}
//**********************************************************************
void CheckForTrailingStop()
{
for(int i=0;i<OrdersTotal();i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
if(OrderSymbol()!=Symbol()) continue;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~`
if((OrderType()==OP_BUY))
{
if(Bid-OrderOpenPrice()>Point*TrailingStop)
{
if(OrderStopLoss()<Bid-Point*TrailingStop)
{
for (int try=1;try<=5;try++)
{
if(OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green))
{
Print("Position :",OrderTicket()," modified StopLoss to ", OrderStopLoss(), " at try ", try);
break;
}
}
}
}
}
if((OrderType()==OP_SELL))
{
if((OrderOpenPrice()-Ask)>(Point*TrailingStop))
{
if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0))
{
for (try=1;try<=5;try++)
{
if(OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red))
{
Print("Position :",OrderTicket()," modified StopLoss to ", OrderStopLoss(), " at try ", try);
break;
}
}
}
}
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
}
return(0);
}
//*******************************************************************
int Positions(int d, int mn) //Âîçâðàùàåò êîëè÷åñòâî îòêðûòûõ
{ //ïîçèöèé
int buys=0,sells=0,positions;
//----
for(int i=0;i<OrdersTotal();i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
if(OrderSymbol()==Symbol())
{
if(OrderMagicNumber() == mn || mn == 0)
{
if(OrderType()==OP_BUY) buys++;
if(OrderType()==OP_SELL) sells++;
}
}
}
switch (d)
{
case 0 : positions = buys; break;
case 1 : positions = sells; break;
case 3 : positions = buys +sells; break;
}
return(positions);
}
Sample
Analysis
Market Information Used:
Series array that contains open time of each bar
Indicator Curves created:
Indicators Used:
Moving average indicator
Custom Indicators Used:
dpnn
djama
Order Management characteristics:
It automatically opens orders when conditions are reached
Checks for the total of open orders
It Closes Orders by itself
It can change open orders parameters, due to possible stepping strategy
Other Features:
