//+------------------------------------------------------------------+
//|                                          i-PSI@MA(MP)_Signal.mq4 |
//|                                                          TarasBY |
//|                                                                  |
//+------------------------------------------------------------------+
#property  copyright "TarasBY © 2010"
#property  link      "taras_bulba@tut.by"
//---- indicator settings
#property  indicator_separate_window
#property  indicator_buffers 8
#property  indicator_color1   Lime
#property  indicator_color2   Magenta
#property  indicator_color3   Red
#property  indicator_color4   Orange
#property  indicator_color5   Yellow
#property  indicator_color6   Green
#property  indicator_color7   DeepSkyBlue
#property  indicator_color8   Blue

#property indicator_level1  0.0
#property indicator_level2  0.01
#property indicator_level3 -0.01
#property indicator_levelcolor RoyalBlue

//---- indicator parameters
extern int      MA_Variant       = 0;               // 0-iMA; 1-VininLRMA; 2-HMA; 3-_HMA; 4-VininI_HMA; 5-J2JMA; 6-Var Mov Avg; 7-EMA_Adaptive_v22;
extern int      Level_Calculate  = 0;               // 1-3: Angle - варианты расчёта угла MA-шек
extern bool     TimeIsBar        = True;            // При расчёте угла наклона МА, единицей времени служит бар
extern string   MA_Periods       = "9,14,25,75,150,300";
extern string   List_TF          = "15,30,60,240";
extern int      Bar_SUM          = 5;               // Количество просчитываемых баров
extern int      MA_MODE          = MODE_EMA;        // 0-SMA; 1-EMA; 2-SMMA; 3-LWMA
extern int      MA_PRICE         = PRICE_CLOSE;     // 0-C; 1-O; 2-H; 3-L; 4-Md; 5-Tp; 6-WghC: Md(HL/2)4,Tp(HLC/3)5,Wgh(HLCC/4)6
//---- indicator buffers
double Buf_Impulse_00[],Buf_Impulse_01[],Buf_Impulse_02[],Buf_Impulse_03[],
Buf_Impulse_04[],Buf_Impulse_05[],Buf_Impulse_UP[],Buf_Impulse_DW[],
gd_Impulse[];
int    Periods[],gi_TF[],
cnt_MA,cnt_TF,FirstRow;
bool   lb_first=true;
string Name,Ind_Name;
color  Cur_color[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   string ls_TF;
//---- Можно использовать максимально 6 буферов
   cnt_MA = MathMin (6, StringToArrayINT (MA_Periods, Periods, ","));
   cnt_TF = fCreatArray_TF (gi_TF, List_TF);
   for(int li_int=0; li_int<cnt_TF; li_int++)
     {ls_TF=StringConcatenate(ls_TF,gi_TF[li_int],IIFs((li_int<cnt_TF-1),",",""));}
   if(List_TF=="0")
     {ls_TF=Period();}
   ArrayResize(gd_Impulse,cnt_MA);
//ArrayResize (Cur_color, cnt_MA);
   ArrayResize(Cur_color,6);

   IndicatorBuffers(cnt_MA+2);
   Ind_Name = StringConcatenate ("MA ([", MA_Variant, "/", Level_Calculate, "] - ", ls_TF, ") Periods (");
   FirstRow = StringLen (Ind_Name);
   Name="MA (MP)";
   Cur_color[0] = indicator_color3;
   Cur_color[1] = indicator_color4;
   Cur_color[2] = indicator_color5;
   Cur_color[3] = indicator_color6;
   Cur_color[4] = indicator_color7;
   Cur_color[5] = indicator_color8;
//---- drawing settings
   SetIndexStyle(0,DRAW_HISTOGRAM);
   SetIndexBuffer(0,Buf_Impulse_UP);
   SetIndexLabel(0,"Imp_UP");
   SetIndexStyle(1,DRAW_HISTOGRAM);
   SetIndexBuffer(1,Buf_Impulse_DW);
   SetIndexLabel(1,"Imp_DW");
//----
   for(int i=2; i<cnt_MA+2; i++)
     {
      switch(i)
        {
         case 2:
            SetIndexStyle(i,DRAW_LINE,0,1,Cur_color[i-2]);
            SetIndexBuffer(i,Buf_Impulse_00);
            SetIndexLabel(i,"Imp_00");
            SetIndexDrawBegin(i,Periods[i-2]);
            break;
         case 3:
            SetIndexStyle(i,DRAW_LINE,0,1,Cur_color[i-2]);
            SetIndexBuffer(i,Buf_Impulse_01);
            SetIndexLabel(i,"Imp_01");
            SetIndexDrawBegin(i,Periods[i-2]);
            break;
         case 4:
            SetIndexStyle(i,DRAW_LINE,0,1,Cur_color[i-2]);
            SetIndexBuffer(i,Buf_Impulse_02);
            SetIndexLabel(i,"Imp_02");
            SetIndexDrawBegin(i,Periods[i-2]);
            break;
         case 5:
            SetIndexStyle(i,DRAW_LINE,0,1,Cur_color[i-2]);
            SetIndexBuffer(i,Buf_Impulse_03);
            SetIndexLabel(i,"Imp_03");
            SetIndexDrawBegin(i,Periods[i-2]);
            break;
         case 6:
            SetIndexStyle(i,DRAW_LINE,0,1,Cur_color[i-2]);
            SetIndexBuffer(i,Buf_Impulse_04);
            SetIndexLabel(i,"Imp_04");
            SetIndexDrawBegin(i,Periods[i-2]);
            break;
         case 7:
            SetIndexStyle(i,DRAW_LINE,0,1,Cur_color[i-2]);
            SetIndexBuffer(i,Buf_Impulse_05);
            SetIndexLabel(i,"Imp_05");
            SetIndexDrawBegin(i,Periods[i-2]);
            break;
        }
      Ind_Name=StringConcatenate(Ind_Name,Periods[i-2],IIFs((i<cnt_MA+1),", ",")"));
     }
//---- name for DataWindow and indicator subwindow label
   IndicatorShortName(Ind_Name);
   IndicatorDigits(MarketInfo(Symbol(),MODE_DIGITS)+2);
//---- initialization done
   return(0);
  }
//+----------------------------------------------------------------------------+
//|  Custom indicator deinitialization function                                |
//+----------------------------------------------------------------------------+
int deinit()
  {
//----
   for(int l_int=0; l_int<cnt_MA; l_int++)
     {
      if(!ObjectDelete(Name+Periods[l_int]))
        {Print("error: code #",GetLastError());}
     }
//----
   return(0);
  }
//+----------------------------------------------------------------------------+
//|  Custom indicator start function                                           |
//+----------------------------------------------------------------------------+
int start()
  {
   double ld_Div,ld_Con,ld_MA,ld_MA_Last,ld_MA_Fast,ld_MA_Slow,ld_MA_VSlow;
   double ld_MA_shift,ld_MA_Last_shift,ld_Angle0,ld_Angle_shift,ld_dAngle,ld_Impulse;
   int nLimit,i,l_int,li_PRD,li_TF;
   int nCountedBars,Impulse_Slow,Impulse_VSlow,li_dist;
//----
   nCountedBars=IndicatorCounted();
   if(nCountedBars<0) return(-1);
   if(nCountedBars>0) nCountedBars--;
   int limit=Bars-nCountedBars;
   if(nCountedBars==0) limit-=1+Bar_SUM;
   nLimit=limit;

   if(lb_first)
     {
      int cur=MathFloor((FirstRow)*IIFd((FirstRow<30),2.6,3.1));
      for(l_int=0; l_int<cnt_MA; l_int++)
        {
         if(ObjectFind(Name+Periods[l_int])!=-1)
           {ObjectDelete(Name+Periods[l_int]);}
         li_dist=IIFi((Periods[l_int]<10),15,IIFi((Periods[l_int]<100),17,19));
         sl(l_int,"~",cur,Cur_color[l_int]);
         cur+=li_dist;
        }
      lb_first=false;
     }

//---- main loop
   for(i=nLimit; i>=0; i--)
     {
      ArrayInitialize(gd_Impulse,0.0);
      for(li_TF=0; li_TF<cnt_TF; li_TF++)
        {
         //ld_Impulse = 0.0;
         for(li_PRD=0; li_PRD<cnt_MA; li_PRD++)
           {
            ld_Div = 0.0;
            ld_Con = 0.0;
            ld_dAngle = 0.0;
            for(l_int = i; l_int < i + Bar_SUM; l_int++)
              {
               ld_MA=fGetMA_Price(MA_Variant,Symbol(),gi_TF[li_TF],Periods[li_PRD],MA_MODE,MA_PRICE,l_int);
               ld_MA_Last=fGetMA_Price(MA_Variant,Symbol(),gi_TF[li_TF],Periods[li_PRD],MA_MODE,MA_PRICE,l_int+1);
               switch(Level_Calculate)
                 {
                  case 0:
                     if(ld_MA>=ld_MA_Last)
                       {ld_Div+=ld_MA-ld_MA_Last;}
                     else
                       {ld_Con+=ld_MA_Last-ld_MA;}
                     break;
                  default:
                     ld_MA_shift=fGetMA_Price(MA_Variant,Symbol(),gi_TF[li_TF],Periods[li_PRD],MA_MODE,MA_PRICE,l_int+Periods[li_PRD]);
                     ld_MA_Last_shift=fGetMA_Price(MA_Variant,Symbol(),gi_TF[li_TF],Periods[li_PRD],MA_MODE,MA_PRICE,l_int+1+Periods[li_PRD]);
                     ld_Angle0=fGetAngleMA(Level_Calculate,Symbol(),gi_TF[li_TF],ld_MA,ld_MA_Last,l_int);
                     ld_Angle_shift=fGetAngleMA(Level_Calculate,Symbol(),gi_TF[li_TF],ld_MA_shift,ld_MA_Last_shift,l_int+Periods[li_PRD]);
                     ld_dAngle+=ld_Angle0-ld_Angle_shift;
                     break;
                 }
              }
            //---- Собираем показания импульса по каждой MA-шке на всех TF
            gd_Impulse[li_PRD]+=fGetImpulse(Level_Calculate,(ld_Div-ld_Con),ld_dAngle);
            if(li_TF<cnt_TF-1)
              {continue;}
            switch(li_PRD)
              {
               case 0: Buf_Impulse_00[i] = gd_Impulse[li_PRD]; break;
               case 1: Buf_Impulse_01[i] = gd_Impulse[li_PRD]; break;
               case 2: Buf_Impulse_02[i] = gd_Impulse[li_PRD]; break;
               case 3: Buf_Impulse_03[i] = gd_Impulse[li_PRD]; break;
               case 4: Buf_Impulse_04[i] = gd_Impulse[li_PRD]; break;
               case 5: Buf_Impulse_05[i] = gd_Impulse[li_PRD]; break;
              }
           }
        }
     }
//----
   for(i=0; i<nLimit; i++)
     {
      ld_Div = 0.0;
      ld_Con = 0.0;
      for(li_PRD=0; li_PRD<cnt_MA; li_PRD++)
        {
         for(l_int=i; l_int<i+Bar_SUM; l_int++)
           {
            switch(li_PRD)
              {
               case 0:
                  if(Buf_Impulse_00[l_int]>=Buf_Impulse_00[l_int+1])
                    {
                     if(Buf_Impulse_00[l_int] >= Buf_Impulse_01[l_int]
                        && Buf_Impulse_01[l_int] >= Buf_Impulse_02[l_int])
                       {ld_Div+=Buf_Impulse_00[l_int]-Buf_Impulse_00[l_int+1];}
                    }
                  else
                    {
                     if(Buf_Impulse_00[l_int]<Buf_Impulse_01[l_int]
                        && Buf_Impulse_01[l_int]<Buf_Impulse_02[l_int])
                       {ld_Con+=Buf_Impulse_00[l_int+1]-Buf_Impulse_00[l_int];}
                    }
                  break;
               case 1:
                  if(Buf_Impulse_01[l_int]>=Buf_Impulse_01[l_int+1])
                    {
                     if(Buf_Impulse_00[l_int] >= Buf_Impulse_01[l_int]
                        && Buf_Impulse_01[l_int] >= Buf_Impulse_02[l_int])
                       {ld_Div+=Buf_Impulse_01[l_int]-Buf_Impulse_01[l_int+1];}
                    }
                  else
                    {
                     if(Buf_Impulse_00[l_int]<Buf_Impulse_01[l_int]
                        && Buf_Impulse_01[l_int]<Buf_Impulse_02[l_int])
                       {ld_Con+=Buf_Impulse_01[l_int+1]-Buf_Impulse_01[l_int];}
                    }
                  break;
               case 2:
                  if(Buf_Impulse_02[l_int]>=Buf_Impulse_02[l_int+1])
                    {
                     if(Buf_Impulse_00[l_int] >= Buf_Impulse_01[l_int]
                        && Buf_Impulse_01[l_int] >= Buf_Impulse_02[l_int])
                       {ld_Div+=Buf_Impulse_02[l_int]-Buf_Impulse_02[l_int+1];}
                    }
                  else
                    {
                     if(Buf_Impulse_00[l_int]<Buf_Impulse_01[l_int]
                        && Buf_Impulse_01[l_int]<Buf_Impulse_02[l_int])
                       {ld_Con+=Buf_Impulse_02[l_int+1]-Buf_Impulse_02[l_int];}
                    }
                  break;
               case 3:
                  if(Buf_Impulse_03[l_int]>=Buf_Impulse_03[l_int+1])
                    {
                     if(Buf_Impulse_01[l_int] >= Buf_Impulse_02[l_int]
                        && Buf_Impulse_02[l_int] >= Buf_Impulse_03[l_int])
                       {ld_Div+=Buf_Impulse_03[l_int]-Buf_Impulse_03[l_int+1];}
                    }
                  else
                    {
                     if(Buf_Impulse_01[l_int]<Buf_Impulse_02[l_int]
                        && Buf_Impulse_02[l_int]<Buf_Impulse_03[l_int])
                       {ld_Con+=Buf_Impulse_03[l_int+1]-Buf_Impulse_03[l_int];}
                    }
                  break;
               case 4:
                  if(Buf_Impulse_04[l_int]>=Buf_Impulse_04[l_int+1])
                    {
                     if(Buf_Impulse_02[l_int] >= Buf_Impulse_03[l_int]
                        && Buf_Impulse_03[l_int] >= Buf_Impulse_04[l_int])
                       {ld_Div+=Buf_Impulse_04[l_int]-Buf_Impulse_04[l_int+1];}
                    }
                  else
                    {
                     if(Buf_Impulse_02[l_int]<Buf_Impulse_03[l_int]
                        && Buf_Impulse_03[l_int]<Buf_Impulse_04[l_int])
                       {ld_Con+=Buf_Impulse_04[l_int+1]-Buf_Impulse_04[l_int];}
                    }
                  break;
               case 5:
                  if(Buf_Impulse_05[l_int]>=Buf_Impulse_05[l_int+1])
                    {
                     if(Buf_Impulse_03[l_int] >= Buf_Impulse_04[l_int]
                        && Buf_Impulse_04[l_int] >= Buf_Impulse_05[l_int])
                       {ld_Div+=Buf_Impulse_05[l_int]-Buf_Impulse_05[l_int+1];}
                    }
                  else
                    {
                     if(Buf_Impulse_03[l_int]<Buf_Impulse_04[l_int]
                        && Buf_Impulse_04[l_int]<Buf_Impulse_05[l_int])
                       {ld_Con+=Buf_Impulse_05[l_int+1]-Buf_Impulse_05[l_int];}
                    }
                  break;
              }
           }
        }
      ld_Impulse=ld_Div-ld_Con;
      if(ld_Impulse>=0)
        {Buf_Impulse_UP[i]=ld_Impulse;}
      else
        {Buf_Impulse_DW[i]=ld_Impulse;}
     }
//----
   return(0);
  }
//+----------------------------------------------------------------------------+
double fGetMA_Price(int MAVariant,string Sym,int TF,int MAPeriod,int MAMode,int MAPrice,int bar=0)
  {
   switch(MAVariant)
     {
      case 1: return(iCustom (Sym, TF, "VininLRMA", MAPeriod, 0, bar));
      case 2: return(iCustom (Sym, TF, "HMA", MAPeriod, 0, bar));
      case 3: return(iCustom (Sym, TF, "_HMA", MAPeriod, MAMode, MAPrice, 0, bar));
      case 4: return(iCustom (Sym, TF, "VininI_HMA", MAPeriod, MAMode, MAPrice, 0, 0, bar));
      case 5: return(iCustom (Sym, TF, "J2JMA", MAPeriod, MAPeriod, 50, 50, 0, MAPrice, 0, bar));
      case 6: return(iCustom (Sym, TF, "Var Mov Avg", MAPeriod, 4, MAPeriod, 2.0, 2.0, 0, bar));
      case 7: return(iCustom (Sym, TF, "EMA_Adaptive_v22", 9, MAPeriod, 5, 1, false, 0, bar));
      default: return(iMA(Sym,TF,MAPeriod,0,MAMode,MAPrice,bar));
     }
//----
   return(0);
  }
//+----------------------------------------------------------------------------+
double fGetImpulse(int Variant,double Value0,double Value1,double Value2=0)
  {
   switch(Variant)
     {
      case 0: return(Value0);
      default: return(Value1);
     }
//----
   return(0);
  }
//+----------------------------------------------------------------------------+
//|           The angle for MA                                                 |
//+----------------------------------------------------------------------------+
double fGetAngleMA(int Variant,string Sym,int Per,double MA_Begin,double MA_End,int Bar_Begin)
  {
//double Пи (3.14) * MathArccos (delta значений времени / sqrt (delta значений времени (напр. в барах)^2 + delta значений МА в начальной и конечной точках данного времени)^2))
   double X,Y,X1,Y1,X2,Y2,K1,K2;
   double Angle_K0,ld_Angle;
   double Pi=3.1415926535;
//----
   if(Per==0)
     {Per=Period();}
   X1=IIFi(TimeIsBar,Bar_Begin,iTime(Sym,Per,Bar_Begin)); Y1=MA_Begin; // Точка А (X1,Y1)
   X2=IIFi(TimeIsBar,Bar_Begin+1,iTime(Sym,Per,Bar_Begin+1)); Y2=MA_End; // Точка В (X2,Y2)
//----
   switch(Variant)
     {
      case 1:
         Y=(X2-X1)/IIFi(TimeIsBar,-1,Per*60);
         if(Y==0)
           {Y=1;}
         X =(Y2-Y1) * IIFi(TimeIsBar,1,Per);
         ld_Angle=MathArctan(X/Y);
         break;
      case 2:
         // Уравнение прямой
         //Angle_K0 = (Y2 - Y1) / (X2 - X1);
         Angle_K0=MA_End-MA_Begin;
         //Angle_K0 * (X - X1) - Y + Y1 = 0;
         // Уравнение 1-ой прямой (наклонной)
         //Angle_K0 * X - Angle_K0 * X1 - Y + Y1 = 0;
         //Y = Angle_K0 * X - Angle_K0 * X1 + Y1;
         K1=Angle_K0;
         // Уравнение 2-ой прямой (параллельной)
         //Y1 - Y = 0;
         //Y = Y1;
         K2=0;
         //ld_Angle = MathTan ((K2 - K1) / (1 + K1 * K2));
         ld_Angle=MathTan(-Angle_K0);
         break;
      case 3:
         X = (X2 - X1) / IIFi (TimeIsBar, -1, Per * 60);
         Y = (Y2 - Y1) * IIFi (TimeIsBar, 1, Per);
         double ld_Sqrt=MathSqrt(MathPow(X,2)+MathPow(Y,2));
         if(ld_Sqrt==0)
           {ld_Sqrt=1;}
         ld_Angle= Pi * MathArccos (X / ld_Sqrt);
         break;
     }
//----
   return(ld_Angle);
  }
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
int IIFi(bool condition,int ifTrue,int ifFalse)
  {
   if(condition)
     {return(ifTrue);}
   else {return(ifFalse);}
  }
//+----------------------------------------------------------------------------+
string IIFs(bool condition,string ifTrue,string ifFalse)
  {
   if(condition)
     {return(ifTrue);}
   else {return(ifFalse);}
  }
//+----------------------------------------------------------------------------+
double IIFd(bool condition,double ifTrue,double ifFalse)
  {
   if(condition)
     {return(ifTrue);}
   else {return(ifFalse);}
  }
//+----------------------------------------------------------------------------+
int StringToArrayINT(string List,int &iArray[],string sDelimiter=",")
  {
   int i=0,num;
   string ls_tmp;
//----
   ArrayResize(iArray,0);
   while(StringLen(List)>0)
     {
      num=StringFind(List,sDelimiter);
      if(num<0)
        {
         ls_tmp=List;
         List="";
        }
      else
        {
         ls_tmp=StringSubstr(List,0,num);
         List=StringSubstr(List,num+1);
        }
      i++;
      ArrayResize(iArray,i);
      iArray[i-1]=StrToDouble(ls_tmp);
     }
//----
   return(ArraySize(iArray));
  }
//+----------------------------------------------------------------------------+
bool sl(int Num,string sym,int y,color col)
  {
   int window=WindowFind(Ind_Name);
   if(window<0)
     {
      Print("Окно с индикатором ",Ind_Name," не найдено !!!");
      return(false);
     }
   string ID=Name+Periods[Num];
   if(ObjectCreate(ID,OBJ_LABEL,window,0,0))
     {
      //ObjectSet(ID, OBJPROP_CORNER, 1);
      ObjectSet(ID,OBJPROP_XDISTANCE,y+35);
      ObjectSet(ID,OBJPROP_YDISTANCE,0);
      ObjectSetText(ID,sym,18,"Arial Black",col);
      return(true);
     }
   return(false);
  }
//+----------------------------------------------------------------------------+
int TimeframeNormalize(int Timeframe)
  {
   int li_TF=0,li_UP=50000,li_DOWN,cnt_TM=9;
   int ar_TM[]={1,5,15,30,60,240,1440,10080,43200};
//----
   if(Timeframe==0)
     {return(Period());}
   for(int li_int=0; li_int<cnt_TM; li_int++)
     {
      if(Timeframe<=ar_TM[li_int])
        {li_UP=MathMin(li_UP,ar_TM[li_int]);}
      if(Timeframe>ar_TM[li_int])
        {li_DOWN=MathMax(li_DOWN,ar_TM[li_int]);}
     }
   li_TF=IIFi((MathAbs(Timeframe-li_UP)<=MathAbs(Timeframe-li_DOWN)),li_UP,li_DOWN);
//----
   return(li_TF);
  }
//+----------------------------------------------------------------------------+
//| Создаём массив TF из строки, контролируя правильность задания TF           |
//+----------------------------------------------------------------------------+
int fCreatArray_TF(int &iAr_TF[],string s_List)
  {
   int li_cnt_TF,li_cnt=0;
//----
   li_cnt_TF=StringToArrayINT(s_List,iAr_TF);
   for(int li_TF=0; li_TF<li_cnt_TF; li_TF++)
     {
      iAr_TF[li_TF]=TimeframeNormalize(iAr_TF[li_TF]);
      if(li_TF>0)
        {
         if(iAr_TF[li_TF]!=iAr_TF[li_cnt])
           {
            li_cnt++;
            iAr_TF[li_cnt]=iAr_TF[li_TF];
           }
         else
           {Print("Не верно задан TF. При нормализации получили дубликат: TF[",li_cnt,"/",iAr_TF[li_cnt],"] = TF[",li_TF,"/",iAr_TF[li_TF],"]- удаляем дубликат!!!");}
        }
     }
   li_cnt++;
   if(li_cnt_TF!=li_cnt)
     {ArrayResize(iAr_TF,li_cnt);}
//----
   return(li_cnt);
  }
//+----------------------------------------------------------------------------+