quantitative analysis

Author: Integer
Price Data Components
Series array that contains close prices for each bar
Indicators Used
Indicator of the average true range
Miscellaneous
It issuies visual alerts to the screenUses files from the file systemIt writes information to fileIt reads information from a file
0 Views
0 Downloads
0 Favorites
quantitative analysis 
ÿþ//+------------------------------------------------------------------+

//|                                          SelfLearningExperts.mq5 |

//|                                         Copyright 2012, Integer. |

//|                          https://login.mql5.com/ru/users/Integer |

//+------------------------------------------------------------------+



#property copyright "Integer"

#property link "https://login.mql5.com/ru/users/Integer"

#property version   "1.00"



#property description "-:A?5@B ?5@5?8A0= A MQ4, 02B>@ lsv (http://www.mql4.com/ru/users/lsv), AAK;:0 =0 >@838=0; - http://codebase.mql4.com/ru/635"



#include <Trade/Trade.mqh>

#include <Trade/SymbolInfo.mqh>

#include <Trade/PositionInfo.mqh>



CTrade Trade;

CSymbolInfo Sym;

CPositionInfo Pos;



input bool     ReadHistory    =  false;         /*'8B0BL 8AB>@8N >?B8<870F88*/      // 'B5=85 A>E@0=5==>9 8AB>@88 >1CG5=8O.

input bool     SaveHistory    =  false;         /*!>E@0=OBL 8AB>@8N >?B8<870F88*/      // !>E@0=OBL 8AB>@8N >1CG5=8O. @8 @01>B5 2 B5AB5@5 8AB>@8O A>E@0=O5BAO ?> 7025@H5=8N B5AB8@>20=8O, ?@8 @01>B5 =0 AG5B5 - @53C;O@=>, ?> <5@5 ?5@5>1CG5=8O.

input double   Lots           =  0.1;           /*>BK 4;O B>@3>2;8*/             // 1J5< ?>78F88

input int      Nidelt         =  20;            /*'8A;> 107>2KE ?0BB5@=>2*/           // >;8G5AB2> @07;8G=KE ?0BB5@=>2

input int      Nstop          =  1;             /*1-2*/            // >;8G5AB2> ?0@0<5B@>2 28@BC0;L=KE ?>78F89 (@07;8G=KE 7=0G5=89 AB>?;>AA0 8 B59:?@>D8B0, AB>?;>AA 8 B59:?@>D8B @02=K)

input int      dstop          =  250;           /*(03 AB>?0 8 B59:0*/            // (03 87<5=5=8O ?0@0<5B@>2 28@BC0;L=>9 ?>78F88 (AB>?;>AA0 8 B59:?@>D8B0)

input double   forg           =  1.05;          /*01K20=85 >?B8<870F88*/             // !:>@>ABL 701K20=8O @57C;LB0B>2 >1CG5=8O, 7=0G5=85 4>;6=> 1KBL =5<=>3> 1>;LH5 1

input double   ProbabSL         =  0.8;           /*5@>OB=>ABL AB>?0*/           // #@>25=L 25@>OB=>AB8 AB>?0 >?@545;5==K9 ?> @57C;LB0B0< >1CG5=8O ?@8 :>B>@>< 2K?>;=O5BAO >B:@KB85 ?>78F88

input double   ProbabTP         =  0.8;           /*5@>OB=>ABL B59:0*/           // #@>25=L 25@>OB=>AB8 B59:0 >?@545;5==K9 ?> @57C;LB0B0< >1CG5=8O ?@8 :>B>@>< 2K?>;=O5BAO >B:@KB85 ?>78F88

input int      NN             =  10;            /* 07<5@ ?0BB5@=0 2 B>G:0E*/               //  07<5@ ?0BB5@=0, =5 1>;LH5 12 

input int      delta          =  10;             /* 07<5@ B>G:8 ?0BB5@=0*/            // (03 87<5=5=8O ?0@0<5B@0 ?0BB5@=0

input bool     ReplaceStops   =  false;         /* 07@5H5=85 =0 <>48D8:0F8N >@45@>2*/     // >48D8F8@>20BL AB>?;>AA/B59:?@>D8B ?@8 =>2KE A83=0;0E >B:@KB8O. 5@5=>A AB>?;>AA0/B59:?@>D8B0 2K?>;=O5BAO B>;L:> ?> =0?@02;5=8N ?>78F88.

input int      Trailing       =  0;             /*"@59;8=3 AB>?*/         // #@>25=L B@59;8=30, ?@8 7=0G5=88 0 B@59;8=3 2K:;NG5=.



bool     Trade_BuyOpenSignal     =  false;   // 5@5<5==K5 4;O B>@3>2KE A83=0;>2 

bool     Trade_SellOpenSignal    =  false; 

bool     Trade_BuyCloseSignal    =  false; 

bool     Trade_SellCloseSignal   =  false;   



double   MarketPattern[12][3000];           // 0AA82 4;O 40==KE B5:CI8E ?0BB5@=>2 >?@5465;5==KE ?> F5=0<

double   MarketPatternLastPrice[3000];      // >A;54=OO F5=0 ?0BB5@=0, 4;O >?@545;5=8O, GB> ?0BB5@= 87<5=8;AO 8 ?> =5<C =C6=> >B:@KBL 28@BC0;L=K9 >@45@



double   PatternDeltaParameter[300];       // 0AA82 A ?0@0<5B@>< ?> :>B>@><C >B;8G0NBAO ?0BB5@=K

int      StopInPointsParameter[3];        // 0AA82 A> 7=0G5=8O<8 AB>?;>AA0 8 B59:?@>D8B0



int      BinaryPattern[50000][300];           // A?><>30B5;L=K9 <0AA82 4;O ?0BB5@=0 2 18=0@=>< 2845



string   Store_FileName;                  // <O D09;0 4;O A>E@0=5=8O >?@545;5==KE 2 @57C;LB0B5 28@BC0L=>9 B>@3>2;8 25@>OB=>AB59

datetime Store_LastSaveTime;              // @5<O ?>A;54=53> >1=>2;5=8O 40==KE 2 D09;5

int      Store_TypesCount;                // 0:A8<0;L=>5 7=0G5=85 =><5@0 18=0@=>3> B8?0 ?0BB5@=0

int      Store_ChangesCount;              // >;8G5AB2> 87<5=5=89 2 <0AA820E 25@>OB=>AB59



double   Store_PowerUp[5000][300][3];      // 5@>OB=>ABL 42865=8O 225@E

double   Store_PowerDn[5000][300][3];      // 5@>OB=>ABL 42865=8O 2=87

int      Store_TradesCount[50000][300][3];  // >;8G5AB2> 28@BC0;L=KE >@45@>2



bool     Store_IsLoaded;                  // $09; 703@C65=



bool     VO_Exists[50000][300][3];          // 0AA82 ACI5AB2>20=8O 28@BC0;L=>3> >@45@0 ?> =><5@C 18=0@=>3> B8?0 ?0BB5@=0 (D>@<5), ?0@0<5B@C ?0BB5@=0 (delta) 8 7=0G5=8N AB>?;>AA0/B59:?@>D8B0

double   VO_OpenPrice[50000][300][3];       // 0AA82 A F5=0<8 >B:@KB8O 28@BC0;L=KE >@45@>2

datetime VO_OpenTime[50000][300][3];        // 0AA82 A> 2@5<5=5< >B:@KB8O 28@BC0;L=KE >@45@>2



datetime LastBuyOpen, LastSellOpen;

int Trade_TakeProfit, Trade_StopLoss;

int Trade_OrdersCount;



int Ncomb;



double Ask,Bid,point;

bool PatternInitialized=false;

double slv,tpv;

int Store_TP_Hits[5000][3000][3]; // >;8G5AB2> CA?5H=KE 4>AB865=89 TP

int Store_SL_Hits[5000][3000][3]; // >;8G5AB2> CA?5H=KE 4>AB865=89 SL

//+------------------------------------------------------------------+

//| Expert initialization function                                   |

//+------------------------------------------------------------------+

int OnInit(){



      //  0AG5B ATR 4;O B5:CI53> A8<2>;0 8 B5:CI53> 2@5<5==>3> ?5@8>40

    double atr = iATR(_Symbol, PERIOD_CURRENT, 3);



    // =8F80;870F8O ?0@0<5B@0 45;LBK 4;O ?0BB5@=>2, C<=>65==0O =0 ATR

    for(int ip = 1; ip <= Nidelt; ip++) { 

        PatternDeltaParameter[ip] = delta * ip * atr; 

    }



    // =8F80;870F8O ?0@0<5B@0 AB>?0 2 ?C=:B0E, B0:65 C<=>65==0O =0 ATR

    for(int is = 1; is <= Nstop; is++) {

        StopInPointsParameter[is] = dstop * is * atr;       

    }    

   Store_FileName="FD_"+Symbol();

   Store_LastSaveTime=0;

   Store_TypesCount=0;

   Store_ChangesCount=0;   

   

   Store_IsLoaded=false;

   

   ReadHistoryFile();    



   if(!Sym.Name(_Symbol)){

      Alert("H81:0 8=8F80;870F88 CSymbolInfo, ?>2>@8B5 ?>?KB:C");    

      return(-1);

   }



   Print("=8F80;870F8O M:A?5@B0 2K?>;=5=0");

   return(0);

}



//+------------------------------------------------------------------+

//| Expert deinitialization function                                 |

//+------------------------------------------------------------------+

void OnDeinit(const int reason){

   SaveHistoryInTester();

}

//+------------------------------------------------------------------+

//| Expert tick function                                             |

//+------------------------------------------------------------------+

void OnTick(){



   if(!PatternInitialized){

      double tmp[1];

         for(int ip = 1;ip<=Nidelt;ip++){ 

            for(int i=1;i<=NN-1;i++){

                  if(CopyClose(_Symbol,PERIOD_CURRENT,i-1,1,tmp)==-1){

                     return;

                  }

               MarketPattern[i][ip]=tmp[0];

            }               

         } 

      PatternInitialized=true;

   }

   

   if(!Sym.RefreshRates()){

      return;  

   }  



   Ask=iClose(Symbol(),PERIOD_M1,1);

   Bid=iClose(Symbol(),PERIOD_M1,1);

   point=Sym.Point();   



   AnaliticModule(); // >A;5 @01>BK MB>9 DC=:F88 <>6=> 8A?>;L7>20BL ?5@5<5==K5 A B>@>3>2K<8 A83=0;0<8

  

   TradeModule();

   

}



void TradeModule(){



   if(Trade_BuyCloseSignal || Trade_SellCloseSignal){

      if(Pos.Select(_Symbol)){

         if(Trade_BuyCloseSignal && Pos.PositionType()==POSITION_TYPE_BUY){

            if(!Trade.PositionClose(_Symbol,Sym.Spread()*3)){

               return;

            }

         }

         if(Trade_SellCloseSignal && Pos.PositionType()==POSITION_TYPE_SELL){

            if(!Trade.PositionClose(_Symbol,Sym.Spread()*3)){

               return;

            }         

         }

      }

   }

   

   if(Trade_BuyOpenSignal || Trade_SellOpenSignal){

      if(!Pos.Select(_Symbol)){

         if(Trade_BuyOpenSignal && !Trade_SellOpenSignal && !Trade_BuyCloseSignal){

            slv=SolveBuySL(Trade_StopLoss);

            tpv=SolveBuyTP(Trade_TakeProfit);

               if(CheckBuySL(slv) && CheckBuyTP(tpv)){

                  Trade.SetDeviationInPoints(Sym.Spread()*3);

                  if(!Trade.Buy(Lots,_Symbol,0,slv,tpv,"")){

                     return;

                  }

               }

               else{

                  Print(">78F8O Buy =5 >B:@K205BAO, 1;87:89 AB>?;>AA 8;8 B59:?@>D8B");

               }  

         }

         if(Trade_SellOpenSignal && !Trade_BuyOpenSignal && !Trade_SellCloseSignal){

            slv=SolveSellSL(Trade_StopLoss);

            tpv=SolveSellTP(Trade_TakeProfit);

               if(CheckSellSL(slv) && CheckSellTP(tpv)){

                  Trade.SetDeviationInPoints(Sym.Spread()*3);

                  if(!Trade.Sell(Lots,_Symbol,0,slv,tpv,"")){

                     return;

                  }

               }

               else{

                  Print(">78F8O Sell =5 >B:@K205BAO, 1;87:89 AB>?;>AA 8;8 B59:?@>D8B");

               }            

         }         

      }

   }



   if(ReplaceStops){

      ChangeSLByNewSignal(Trade_StopLoss,Trade_TakeProfit); // A<5I5=85 AB>?>2 ?@8 ?>2B>@=KE ?@8:070E =0 >B:@KB85 ?>78F88 B>3> 65 B8?0 

   }      

      

   fSimpleTrailing();

   

}



//+------------------------------------------------------------------+

//| $C=:F8O A0<>>1CG5=8O =0 >A=>25 28@BC0;L=>9 B>@3>2;8              |

//+------------------------------------------------------------------+

void AnaliticModule() {

   Trade_BuyOpenSignal = false;

   Trade_SellOpenSignal = false;

   Trade_BuyCloseSignal = false;

   Trade_SellCloseSignal = false;



   for (int ip = 1; ip <= Nidelt; ip++) { // > 2A5< B5:CI8< ?0BB5@=0< @07=>3> ?0@0<5B@0

      if (MathAbs(Ask - MarketPattern[1][ip]) > point * (PatternDeltaParameter[ip] - 0.5)) {

         Push(ip, Ask);

      }

   }



   for (int ip = 1; ip <= Nidelt; ip++) {

      if (MathAbs(MarketPattern[1][ip] - MarketPatternLastPrice[ip]) <= point * 0.5) continue;

      SetPriceChangeDirection(ip);

      Ncomb = SolvePatternCodedNumber(ip, Store_TypesCount);

      for (int is = 1; is <= Nstop; is++) {

         if (!VO_Exists[Ncomb][ip][is] && TimeToUpdate(VO_OpenTime[Ncomb][ip][is])) {

            VO_Exists[Ncomb][ip][is] = true;

            VO_OpenPrice[Ncomb][ip][is] = Ask;

            VO_OpenTime[Ncomb][ip][is] = TimeCurrent();

         }

      }



  // &8:; ?> 2A5< C@>2=O< AB>?0

for (int is = 1; is <= Nstop; is++) {

    StopInPointsParameter[is] = dstop * is;

    // &8:; ?> 2A5< B8?0< ?0BB5@=>2

    for (int ti = 0; ti <= Store_TypesCount - 1; ti++) {

        // @>25@O5<, ACI5AB2C5B ;8 28@BC0;L=K9 >@45@

        if (VO_Exists[ti][ip][is]) {

            // @>25@O5< CA;>285 4;O B59:-?@>D8B0

if (Ask - VO_OpenPrice[ti][ip][is] > point * StopInPointsParameter[is]) {

    // #A;>285 B59:-?@>D8B0 2K?>;=5=>, >1=>2;O5< AB0B8AB8:C

    VO_Exists[ti][ip][is] = false;

    Store_PowerUp[ti][ip][is] = Store_PowerUp[ti][ip][is] / forg + 1;

    Store_PowerDn[ti][ip][is] = Store_PowerDn[ti][ip][is] / forg;

    Store_TradesCount[ti][ip][is]++;

    Store_TP_Hits[ti][ip][is]++; // !G8B05< 28@BC0;L=K5 ?>?040=8O 2 TP



    // >38@C5< 87<5=5=85 Store_TP_Hits

    Print("TP hit incremented for pattern ", ti, " price level ", ip, " stop level ", is, 

          ". New TP_Hits: ", Store_TP_Hits[ti][ip][is], 

          ", SL_Hits: ", Store_SL_Hits[ti][ip][is]);

}



// @>25@O5< CA;>285 4;O AB>?-;>AA0

if (VO_OpenPrice[ti][ip][is] - Ask > point * StopInPointsParameter[is]) {

    // #A;>285 AB>?-;>AA0 2K?>;=5=>, >1=>2;O5< AB0B8AB8:C

    VO_Exists[ti][ip][is] = false;

    Store_PowerDn[ti][ip][is] = Store_PowerDn[ti][ip][is] / forg + 1;

    Store_PowerUp[ti][ip][is] = Store_PowerUp[ti][ip][is] / forg;

    Store_TradesCount[ti][ip][is]++;

    Store_SL_Hits[ti][ip][is]++; // !G8B05< 28@BC0;L=K5 ?>?040=8O 2 SL



    // >38@C5< 87<5=5=85 Store_SL_Hits

    Print("SL hit incremented for pattern ", ti, " price level ", ip, " stop level ", is, 

          ". New SL_Hits: ", Store_SL_Hits[ti][ip][is], 

          ", TP_Hits: ", Store_TP_Hits[ti][ip][is]);

}

        }

    }

}



      for (int is = 1; is <= Nstop; is++) {

         double prob_UP, prob_DN;

         CalculateProbability(prob_UP, prob_DN, Ncomb, ip, is);



          //  0AAG8BK205< 25@>OB=>AB8 4>AB865=8O TP ?> >B=>H5=8N : SL

double prob_TP = CalculateTPtoSLRatio(Store_TP_Hits[Ncomb][ip][is], Store_SL_Hits[Ncomb][ip][is]);

double prob_SL = CalculateTPtoSLRatio(Store_SL_Hits[Ncomb][ip][is], Store_TP_Hits[Ncomb][ip][is]); // A;8 =C6=> ?>AG8B0BL 25@>OB=>ABL SL

        

        double SL = StopInPointsParameter[is]; // !B>?-;>AA

        double TP = StopInPointsParameter[is]; // "59:-?@>D8B



         if (prob_UP > prob_DN) {

            TP = SL*2;

         } else {

            TP = SL*2;

         }

         Print("prob_TP = ", prob_TP, " for pattern ", ip, " at stop level ", is);

         if (prob_UP > 0.5 && Store_TradesCount[Ncomb][ip][is] > 10 && TimeToUpdate(LastBuyOpen) && prob_SL < ProbabSL && prob_TP > ProbabTP) {

            Trade_TakeProfit = TP;

            Trade_StopLoss = SL;

            Trade_BuyOpenSignal = true;

            CheckSetSellCloseSignal(prob_UP, Trade_SellCloseSignal);

         }



         if (prob_DN > 0.5 && Store_TradesCount[Ncomb][ip][is] > 10 && TimeToUpdate(LastSellOpen) && prob_SL < ProbabSL && prob_TP > ProbabTP) {

            Trade_TakeProfit = TP;

            Trade_StopLoss = SL;

            Trade_SellOpenSignal = true;

            CheckSetBuyCloseSignal(prob_DN, Trade_BuyCloseSignal);

         }

      }



      Store_ChangesCount++;

      MarketPatternLastPrice[ip] = MarketPattern[1][ip];

   }



   SaveHistoryOnAccount();

}



//  0AG5B 25@>OB=>AB8 4>AB865=8O TP ?> >B=>H5=8N : SL

double CalculateTPtoSLRatio(int TP_hits, int SL_hits) {

    int total = TP_hits + SL_hits; // 1I55 :>;8G5AB2> TP 8 SL

    if (total == 0) return 0.0; // 715305< 45;5=8O =0 =>;L

    return (double)TP_hits / total; // 5@>OB=>ABL TP :0: >B=>H5=85 TP : >1I5<C :>;8G5AB2C TP 8 SL

}



// $C=:F8O 4;O @0AG5B0 25@>OB=>AB59 ?>4J5<0 8 ?045=8O F5=K

void CalculateProbability(double &prob_UP, double &prob_DN, int Ncomb, int ip, int is) {

    prob_UP = Store_PowerUp[Ncomb][ip][is] / (Store_PowerUp[Ncomb][ip][is] + Store_PowerDn[Ncomb][ip][is] + 0.0001);

    prob_DN = Store_PowerDn[Ncomb][ip][is] / (Store_PowerUp[Ncomb][ip][is] + Store_PowerDn[Ncomb][ip][is] + 0.0001);

}



//+------------------------------------------------------------------+

//| >102;5=85 =>2>9 B>G:8 2 ?0BB5@= 8 C40;5=85 AB0@>9               |

//+------------------------------------------------------------------+

void Push(int aPattern,double aValue){

      for(int i=1;i<=NN - 1; i++){ //3

         MarketPattern[NN+1-i][aPattern]=MarketPattern[NN-i][aPattern];  

      } //3

   MarketPattern[1][aPattern]=aValue; 

}  



//+------------------------------------------------------------------+

//| >;CG5=85 18=0@=>3> ?0BB5@=0                                     |

//+------------------------------------------------------------------+

void SetPriceChangeDirection(int aPattern){

   for(int i=1;i<=NN-1;i++){ //3

      if(MarketPattern[i][aPattern]>MarketPattern[i+1][aPattern]){//4

         BinaryPattern[i][aPattern]=1;

      }

      else {

         BinaryPattern[i][aPattern]=0;

      }

   }

}



//+------------------------------------------------------------------+

//| KG8A;5=85 ?>@O4:>2>3> =><5@0 ?0BB5@=0 ?> 53> 18=0@=><C 284C     |

//+------------------------------------------------------------------+

int SolvePatternCodedNumber(int aPattern,int & aPatternsLimit){

   int Num=0;  

   int Mult=1;    

      for(int i=1;i<=NN-1;i++){

         Num=Num+Mult*BinaryPattern[i][aPattern]; 

         Mult=2*Mult;

      }

   aPatternsLimit=Mult;

   return(Num);

}



//+------------------------------------------------------------------+

//| @>25@:0 8AB5G5=8O B09<0CB0                                      |

//+------------------------------------------------------------------+

bool TimeToUpdate(datetime aLastTime){

   return(TimeCurrent()-aLastTime>2*Period()*60);

}   



//+------------------------------------------------------------------+

//| @>25@:0 CA;>289 =0 70:@K85 ?>:C?:8                              |

//+------------------------------------------------------------------+  

void CheckSetBuyCloseSignal(double prob,bool & BuyCloseSignal){

      if(Pos.Select(_Symbol)){

         if(Pos.PositionType()==POSITION_TYPE_BUY){

            double p=ReadProbFromFile("FDlast_buy"+Symbol()+IntegerToString(PeriodSeconds()/60));

               if(prob>(p+0.05)){

                  BuyCloseSignal=true; 

               }

         }

      }

   SaveProbToFile("FDlast_buy"+Symbol()+IntegerToString(PeriodSeconds()/60),prob);

}



//+------------------------------------------------------------------+

//| @>25@:0 CA;>289 =0 70:@KB85 ?@>4068                             |

//+------------------------------------------------------------------+  

void CheckSetSellCloseSignal(double prob,bool & SellCloseSignal){

      if(Pos.Select(_Symbol)){

         if(Pos.PositionType()==POSITION_TYPE_SELL){

            double p=ReadProbFromFile("FDlast_sell"+Symbol()+IntegerToString(PeriodSeconds()/60));

               if(prob>(p+0.05)){

                  SellCloseSignal=true; 

               }

         }

      }                        

   SaveProbToFile("FDlast_sell"+Symbol()+IntegerToString(PeriodSeconds()/60),prob);

}  



//+------------------------------------------------------------------+

//| !>E@0=5=85 >4=>3> 7=0G5=8O B5:CI59 25@>OB=>AB8 2 D09;            |

//+------------------------------------------------------------------+

void SaveProbToFile(string aFileName,double aProb){

//Print(aFileName);

   int h=FileOpen(aFileName,FILE_CSV|FILE_WRITE|FILE_COMMON); 

   FileWrite(h,aProb); 

   FileClose(h);

}



//+------------------------------------------------------------------+

//| @>25@:0 CA;>289 =0 70:@KB85 ?>:C?:8 2                           |

//+------------------------------------------------------------------+  

void CheckSetBuyCloseSignal2(int aPattern,int aStop,double aProb,bool & SellCloseSignal){

   if(Pos.Select(_Symbol)){

      if(Pos.PositionType()==POSITION_TYPE_BUY){

         if(aProb>0.99 && Store_TradesCount[Ncomb][aPattern][aStop]>10 && (Bid-Pos.PriceOpen())>point*(dstop/2)){//7

            Trade_BuyCloseSignal=true; 

         }

      }

   }

}  



//+------------------------------------------------------------------+

//| @>25@:0 CA;>289 =0 70:@KB85 ?@>4068 2                           |

//+------------------------------------------------------------------+  

void CheckSetSellCloseSignal2(int aPattern,int aStop,double aProb,bool & SellCloseSignal){                     

   if(Pos.Select(_Symbol)){

      if(Pos.PositionType()==POSITION_TYPE_SELL){

         if(aProb>0.99 && Store_TradesCount[Ncomb][aPattern][aStop]>10 && (Pos.PriceOpen()-Ask)>point*(dstop/2)){

            SellCloseSignal=true; 

         }

      }

   }

} 



//+------------------------------------------------------------------+

//| !>E@0=5=85 @57C;LB0B>2 >1CG5=85 2 D09; ?@8 @01>B5 =0 AG5B5       |

//| K7K205BAO ?5@8>48G=>                                            |

//+------------------------------------------------------------------+  

void SaveHistoryOnAccount(){

   if(SaveHistory){ 

      if(!MQL5InfoInteger(MQL5_TESTING)){

         if(Store_ChangesCount>10 && TimeCurrent()>=Store_LastSaveTime){ //1

            Store_ChangesCount=0; 

            WriteDataToFile();

         } //1

      }  

   }

}   



//+------------------------------------------------------------------+

//| !>E@0=5=85 @57C;LB0B>2 >1CG5=85 2 D09; ?@8 @01>B5 2 B5AB5@5      |

//| K7K205BAO ?@8 458=8F80;870F88 M:A?5@B0                           |

//+------------------------------------------------------------------+  

void SaveHistoryInTester(){

   if(SaveHistory){ 

      if(MQL5InfoInteger(MQL5_TESTING)){

         WriteDataToFile();

      }  

   }

}



//+------------------------------------------------------------------+

//| 03@C7:0 >4=>3> 7=0G5=8O ?>A;54=59 25@>OB=>AB8 87 D09;0          |

//+------------------------------------------------------------------+

double ReadProbFromFile(string aFileName){

   int h=FileOpen(aFileName,FILE_CSV|FILE_READ|FILE_WRITE|FILE_COMMON); 

   double p=FileReadNumber(h); 

   FileClose(h);

   return(p);

}



//+------------------------------------------------------------------+

//| !>E@0=5=85 <0AA82>2 A 40==K<8 >1CG5=8O 2 D09;                    |

//+------------------------------------------------------------------+

void WriteDataToFile(){

   int h=FileOpen(Store_FileName,FILE_CSV|FILE_WRITE|FILE_COMMON); 

   FileWrite(h,TimeCurrent()); 

   FileWrite(h,Store_TypesCount);

   Print("h="+h) ;

      for(int is=1;is<=Nstop;is++){ //2

         for(int ip=1;ip<=Nidelt;ip++){ //3

            for(int ti=0;ti<=Store_TypesCount-1;ti++){ //4

               FileWrite(h,Store_PowerUp[ti][ip][is]); 

               FileWrite(h,Store_PowerDn[ti][ip][is]); 

               FileWrite(h,Store_TradesCount[ti][ip][is]); 

            }//4

         }//3

      } //2

   FileClose(h);  

}



//+------------------------------------------------------------------+

//| 03@C7:0 40==KE >1CG5=8O                                         |

//+------------------------------------------------------------------+

void ReadHistoryFile(){

   if(!Store_IsLoaded){ //1

      Store_IsLoaded=true;

         if(ReadHistory){

            ReadDataFromFile(Store_TypesCount);   

         }

   } //1

}  



//+------------------------------------------------------------------+

//| 'B5=85 D09;0 A 40==K<8 >1CG5=8O                                  |

//+------------------------------------------------------------------+

void ReadDataFromFile(int & aTypesCount){

   int h=FileOpen(Store_FileName,FILE_CSV|FILE_READ|FILE_COMMON);

   Store_LastSaveTime=(datetime)FileReadNumber(h); 

   aTypesCount=(int)FileReadNumber(h); 

      for(int is=1;is<=Nstop;is++){ //3

         for(int ip=1;ip<=Nidelt;ip++){ //4

            for(int ti=0;ti<=aTypesCount-1;ti++){ //5

               Store_PowerUp[ti][ip][is]=FileReadNumber(h); 

               Store_PowerDn[ti][ip][is]=FileReadNumber(h); 

               Store_TradesCount[ti][ip][is]=(int)FileReadNumber(h); 

            }//5

         }//4

      }//3  

   FileClose(h); 

}





//+------------------------------------------------------------------+

//|   $C=:F8O 2KG8A;5=8O AB>?;>AA0 buy                               |

//+------------------------------------------------------------------+

double SolveBuySL(int StopLossPoints){

   if(StopLossPoints==0)return(0);

   return(Sym.NormalizePrice(Sym.Ask()-Sym.Point()*StopLossPoints));

}



//+------------------------------------------------------------------+

//|   $C=:F8O 2KG8A;5=8O B59:?@>D8B0 buy                             |

//+------------------------------------------------------------------+

double SolveBuyTP(int TakeProfitPoints){

   if(TakeProfitPoints==0)return(0);

   return(Sym.NormalizePrice(Sym.Ask()+Sym.Point()*TakeProfitPoints));   

}



//+------------------------------------------------------------------+

//|   $C=:F8O 2KG8A;5=8O AB>?;>AA0 sell                               |

//+------------------------------------------------------------------+

double SolveSellSL(int StopLossPoints){

   if(StopLossPoints==0)return(0);

   return(Sym.NormalizePrice(Sym.Bid()+Sym.Point()*StopLossPoints));

}



//+------------------------------------------------------------------+

//|   $C=:F8O 2KG8A;5=8O B59:?@>D8B0 sell                             |

//+------------------------------------------------------------------+

double SolveSellTP(int TakeProfitPoints){

   if(TakeProfitPoints==0)return(0);

   return(Sym.NormalizePrice(Sym.Bid()-Sym.Point()*TakeProfitPoints));   

}



//+------------------------------------------------------------------+

//|   $C=:F8O 2KG8A;5=8O <8=8<0;L=>3> AB>?;>AA0 buy                  |

//+------------------------------------------------------------------+

double BuyMSL(){

   return(Sym.NormalizePrice(Sym.Bid()-Sym.Point()*Sym.StopsLevel()));

}



//+------------------------------------------------------------------+

//|   $C=:F8O 2KG8A;5=8O <8=8<0;L=>3> B59:?@>D8B0 buy                |

//+------------------------------------------------------------------+

double BuyMTP(){

   return(Sym.NormalizePrice(Sym.Ask()+Sym.Point()*Sym.StopsLevel()));

}



//+------------------------------------------------------------------+

//|   $C=:F8O 2KG8A;5=8O <8=8<0;L=>3> AB>?;>AA0 sell                 |

//+------------------------------------------------------------------+

double SellMSL(){

   return(Sym.NormalizePrice(Sym.Ask()+Sym.Point()*Sym.StopsLevel()));

}



//+------------------------------------------------------------------+

//|   $C=:F8O 2KG8A;5=8O <8=8<0;L=>3> B59:?@>D8B0 sell               |

//+------------------------------------------------------------------+

double SellMTP(){

   return(Sym.NormalizePrice(Sym.Bid()-Sym.Point()*Sym.StopsLevel()));

}



//+------------------------------------------------------------------+

//|   $C=:F8O ?@>25@:8 AB>?;>AA0 buy                                 |

//+------------------------------------------------------------------+

bool CheckBuySL(double StopLossPrice){

   if(StopLossPrice==0)return(true);

   return(StopLossPrice<BuyMSL());

}



//+------------------------------------------------------------------+

//|   $C=:F8O ?@>25@:8 B59:?@>D8B0 buy                               |

//+------------------------------------------------------------------+

bool CheckBuyTP(double TakeProfitPrice){

   if(TakeProfitPrice==0)return(true);

   return(TakeProfitPrice>BuyMTP());

}



//+------------------------------------------------------------------+

//|   $C=:F8O ?@>25@:8 AB>?;>AA0 sell                                 |

//+------------------------------------------------------------------+

bool CheckSellSL(double StopLossPrice){

   if(StopLossPrice==0)return(true);

   return(StopLossPrice>SellMSL());

}



//+------------------------------------------------------------------+

//|   $C=:F8O ?@>25@:8 B59:?@>D8B0 sell                              |

//+------------------------------------------------------------------+

bool CheckSellTP(double TakeProfitPrice){

   if(TakeProfitPrice==0)return(true);

   return(TakeProfitPrice<SellMTP());

}



//+------------------------------------------------------------------+

//| $C=:F8O ?@>AB>3> B@59;8=30                                       |

//+------------------------------------------------------------------+

void fSimpleTrailing(){

   if(Trailing<=0){

      return;

   }         

   if(!Pos.Select(_Symbol)){

      return;

   }         

   if(!Sym.RefreshRates()){

      return;  

   }   

   double nsl,tmsl,psl;  

   switch(Pos.PositionType()){

      case POSITION_TYPE_BUY:

         nsl=Sym.NormalizePrice(Sym.Bid()-_Point*Trailing);

            if(nsl>=Sym.NormalizePrice(Pos.PriceOpen())){

               if(nsl>Sym.NormalizePrice(Pos.StopLoss())){

                  tmsl=Sym.NormalizePrice(Sym.Bid()-_Point*Sym.StopsLevel());

                     if(nsl<tmsl){

                        Trade.PositionModify(_Symbol,nsl,Pos.TakeProfit());

                     }

               }

            }

      break;

      case POSITION_TYPE_SELL:

         nsl=Sym.NormalizePrice(Sym.Ask()+_Point*Trailing);

            if(nsl<=Sym.NormalizePrice(Pos.PriceOpen())){

               psl=Sym.NormalizePrice(Pos.StopLoss());

                  if(nsl<psl || psl==0){

                     tmsl=Sym.NormalizePrice(Sym.Ask()+_Point*Sym.StopsLevel());

                        if(nsl>tmsl){

                           Trade.PositionModify(_Symbol,nsl,Pos.TakeProfit());

                        }

                  }

            }      

      break;

   }

}



//+------------------------------------------------------------------+

// !<5I5=85 AB>?;>AA 8 B59:?@>D8B >B:@KBKE >@45@>2 ?@8 =>2>< A83=0;5 |

// K?>;=O5BAO B>;L:> ?> E>4C 42865=8O                               |

//+------------------------------------------------------------------+

void ChangeSLByNewSignal(int stop,int take){

   if(Pos.Select(_Symbol)){

      if(Pos.PositionType()==POSITION_TYPE_BUY && Trade_BuyOpenSignal){

         double nsl=Sym.NormalizePrice(Bid-point*stop);

            if(nsl>Sym.NormalizePrice(Pos.StopLoss())){

               Trade.PositionModify(_Symbol,nsl,Sym.NormalizePrice(Bid+point*take));

            }

      }

      if(Pos.PositionType()==POSITION_TYPE_SELL &&  Trade_SellOpenSignal){

         double nsl=Sym.NormalizePrice(Ask+point*stop);   

            if(nsl<Sym.NormalizePrice(Pos.StopLoss())){

               Trade.PositionModify(_Symbol,nsl,Sym.NormalizePrice(Ask-point*take));

            }

      }

   }

}

Similar scripts

divergence_trader

Exp_DEMA_Range_Channel_Tm_Plus

Comments

Markdown supported. Formatting help

Markdown Formatting Guide

Element Markdown Syntax
Heading # H1
## H2
### H3
Bold **bold text**
Italic *italicized text*
Link [title](https://www.example.com)
Image ![alt text](image.jpg)
Code `code`
Code Block ```
code block
```
Quote > blockquote
Unordered List - Item 1
- Item 2
Ordered List 1. First item
2. Second item
Horizontal Rule ---