//+------------------------------------------------------------------+
//|                                                      ProjectName |
//|                                      Copyright 2012, CompanyName |
//|                                       http://www.companyname.net |
//+------------------------------------------------------------------+
#property indicator_separate_window // в подокне
#property indicator_buffers 7
#property indicator_color1 Red // сигнальная
#property indicator_color6 Blue // гистограмма динамики длины выборки
#property indicator_maximum 1
#property indicator_minimum 0

// входные параметры
//-- редкоюзаемые параметры сделаны не extern - можно расширить ввод при желании
extern int Source=1; // 0 - объем; 1 - ст.девиация цены; 2 - ATR; 3 - цена; 
extern int ApplPrice=0; // 0 - Close; 4 - (high+low)/2; 5 - (high+low+close)/3; 6 - (high+low+close+close)/4;
extern int SourcePeriod=5; // период входного индикатора
extern int Shift=0; // сдвиг
bool MAtypeI=1; // 0 - SMA, 1 - EMA
extern int PrePeriod=1; // для девиации дополнительное сглаживание, остальные - медленная MA для MACD
bool MAtypeP=1; // 0 - SMA, 1 - EMA
extern int Window=15; // длина выборки нормирования
extern int WindowLimit=0; // множитель ограничение длины выборки нормирования
extern int WindowShift=0; // сдвиг выборки нормирования
extern bool WindowMethod=0; // 0 - фиксированная выборка для нормирования, 1 - плавающая
extern double Sensitivity=0; // чувствительность
extern bool abs=1; // вывод через буфер NP[] со знаком движения ст.девиации
extern bool ToRange=1; // принудительное ограничение диап. 0...1; имеет смысл только при WindowShift>0
extern double Power=1; // степень по нормированию
extern int Signal=1; // сглаживание нормированного индикатора (сигнальная)
bool MAtypeS=1; // 0 - SMA, 1 - EMA
extern int SignalShift=0; // сдвиг сигнальной
extern int History=0;

// индикаторные буферы
double Ind[],// нормируемый индикатор
PR[],// префильтрация
NORM[],// результаты нормирования
SM[],// сигнальная
Input[],// буфер аргументов нормируемого индикатора (цена или объем)
MA[], // МА нормируемого индикатора
NP[], // плавающий период нормирования - в вычислиниях не участвует - для наглядности
SIGN[]; // емулированный буфер - вспомогательная MA

double sens,// чувствительность в масштабе цены/объема
sensLimit,// минимальная чувсвительность
sn,
IndPeriodK, // коэфф. EMA для девиации
PrePeriodK, // коэфф. EMA для префильтра
SignalK; // коэфф. EMA для сглаживания
bool Em=0; // флаг для эмуляции вспомогательной MA
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
           //int WindowLimit; // ограничение длины выборки нормирования

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   switch(Source) 
     {
      case 0: // Объем
         SetIndexStyle(2,DRAW_LINE,0,1,LimeGreen);
         string ShortName="Volume(";
         double punkt=1;
         WindowShift++;
         break;
      case 3: // Стохастик
         SetIndexStyle(2,DRAW_LINE,0,1,LightSeaGreen);
         ShortName="MA(";
         WindowMethod=1; // использовать плавающую длину выборки нормирования
         punkt=Point;
         break;
      case 2: // ст.девиация
         SetIndexStyle(2,DRAW_LINE,0,1,MediumSeaGreen);
         ShortName="StDev(";
         punkt=Point;
         break;
      case 1: //ATR
         SetIndexStyle(2,DRAW_LINE,0,1,DodgerBlue);
         ShortName="ATR(";
         punkt=Point;
     }
   if(WindowMethod) 
     {
      if(WindowLimit==0) WindowLimit=Window*10; // ограничение длины выборки нормирования
      else WindowLimit=MathMax(WindowLimit,Window);
     }
   ShortName=ShortName+_Price()+SourcePeriod;
   if(Shift>0) ShortName=ShortName+"+"+Shift;
   ShortName=ShortName+") ";
   if(PrePeriod>1) ShortName=ShortName+PrePeriod+" ";
   ShortName=ShortName+"["+Window;
   if(WindowMethod && Sensitivity>0) ShortName=ShortName+"_"+WindowLimit;
   if(WindowShift>0) ShortName=ShortName+"+"+WindowShift;
   if(Sensitivity>0) ShortName=ShortName+"@"+DoubleToStr(Sensitivity,1);
   ShortName=ShortName+"]";
   if(Power!=1) ShortName=ShortName+"^"+DoubleToStr(Power,1);
   if(Signal>1 || SignalShift>0) 
     {
      ShortName=ShortName+" ("+Signal;
      if(SignalShift>0) ShortName=ShortName+"+"+SignalShift;
      ShortName=ShortName+")";
     }
   IndicatorShortName(ShortName); // задать имя индикатора в подокне

//---- indicators
   SetIndexBuffer(0,SM); // сигнальная
   SetIndexStyle(0,DRAW_LINE);
   SetIndexLabel(0,"Signal");

   SetIndexBuffer(1,Ind); // индикатор
   SetIndexStyle(1,DRAW_NONE);
   SetIndexLabel(1,NULL);

   SetIndexBuffer(2,NORM); // результаты нормирования
   SetIndexLabel(2,"Normed");

   SetIndexBuffer(3,MA); // MA индикатора
   SetIndexStyle(3,DRAW_NONE);
   SetIndexLabel(3,NULL);

   SetIndexBuffer(4,Input); // буфер входных данных (объем или цена)
   SetIndexStyle(4,DRAW_NONE);
   SetIndexLabel(4,NULL);

   SetIndexBuffer(5,NP); // гистограмма и вывод со знаком ст.дев.
   if(Source==-3 && Sensitivity>0) // показать длину выборки нормирования
     {
      SetIndexStyle(5,DRAW_HISTOGRAM);
      Source=-Source;
     }
   else SetIndexStyle(5,DRAW_NONE);

   if(Source==3 && Sensitivity>0) SetIndexLabel(5,"Window");
   else SetIndexLabel(5,NULL);
   if(abs) SetIndexLabel(5,"NormSign");
   else SetIndexLabel(5,NULL);

   SetIndexBuffer(6,PR); // результаты префильтрации индикатора (подаются в нормирование)
   SetIndexStyle(6,DRAW_NONE);
   SetIndexLabel(6,"Source");

//----
   sensLimit=punkt/1000; // минимальная чувсвительность
   sens=MathMax(Sensitivity*punkt,sensLimit); // чувствительность в масштабе индикатора

   if(WindowMethod) sn=sensLimit; // если динамическое нормирование
   else sn=sens;

   if(SourcePeriod<0) {MAtypeI=0; SourcePeriod=-SourcePeriod;} // SMA
   else IndPeriodK=2.0/(SourcePeriod+1); // EMA

   if(PrePeriod<0) {MAtypeP=0; PrePeriod=-PrePeriod;} // SMA
   else PrePeriodK=2.0/(PrePeriod+1); // EMA

   if(Signal<0) {MAtypeS=0; Signal=-Signal;} // SMA
   else SignalK=2.0/(Signal+1); // EMA

   if(Source==0 || Source==1) Em=1; // флаг для эмуляции вспомогательной MA

   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   if(Em) EmBuff();
//int ic=IndicatorCounted();
//if(Bars-ic-1>1) {ic=reinit();}
//int limit=Bars-ic-1; //BarsPrev=Bars; // кол-во пересчетов
//if(History!=0 && limit>History) limit=History-1; // кол-во пересчетов по истории

   int counted_bars=IndicatorCounted();
   if(counted_bars<0) return(-1);
   if(counted_bars>0) counted_bars--;
   int limit=Bars-counted_bars;
   if(counted_bars==0) limit-=1+5;

   for(int i=limit; i>=0; i--) // цикл по непосчитанным и предпоследнему барам
     {
      double ma;
      int n;
      int iShift=i+Shift;
      if(Em) 
        { // Эмулируемая МА
         if(MAtypeI) // EMA
            SIGN[i]=IndPeriodK*Price(4,iShift)+(1-IndPeriodK)*SIGN[i+1];
         else 
           { // SMA
            int sh=iShift+SourcePeriod;
            ma=SIGN[i+1]*SourcePeriod-Price(4,sh);
            SIGN[i]=(ma+Close[iShift])/SourcePeriod;
           }
        }

      // выбор источника
      switch(Source) 
        {
         case 0: // объем
            Input[i]=Volume[iShift]; break;
         case 3: // цена
            Input[i]=Price(ApplPrice,iShift); break;
         case 2:
            Input[i]=Price(ApplPrice,iShift); break;
         case 1: // ATR
            Input[i]=MathMax(High[iShift],Close[iShift+1])-MathMin(Low[iShift],Close[iShift+1]);
        }

      // MA
      if(MAtypeI) 
        { // EMA
         MA[i]=IndPeriodK*Input[i]+(1-IndPeriodK)*MA[i+1];
         ma=MA[i];
        }
      else 
        { // SMA
         sh=i+SourcePeriod;
         ma=MA[i+1]*SourcePeriod-Input[sh];
         MA[i]=(ma+Input[i])/SourcePeriod;
         ma=MA[i];
        }

      // ст.девиация
      if(Source==2) // нормируется девиация
        {
         double std=0;
         for(n=0; n<SourcePeriod; n++) 
           {
            double delta=Input[i+n]-ma;
            std+=delta*delta;  // числитель SourcePeriod(Price)
           }
         Ind[i]=MathSqrt(std/SourcePeriod);
         //
         if(PrePeriod==1) PR[i]=Ind[i];
         else
         if(MAtypeP)
            PR[i]=PrePeriodK*Ind[i]+(1-PrePeriodK)*PR[i+1];
         else  
           {
            sh=i+PrePeriod;
            ma=PR[i+1]*PrePeriod-Ind[sh];
            PR[i]=(ma+Ind[i])/PrePeriod;
           }
        }
      else // MA (цена или объем)
      if(PrePeriod==1) PR[i]=MA[i];
      else 
        {
         if(MAtypeP)
            Ind[i]=PrePeriodK*Input[i]+(1-PrePeriodK)*Ind[i+1];
         else 
           {
            sh=i+PrePeriod;
            ma=PR[i+1]*PrePeriod-Input[sh];
            Ind[i]=(ma+Input[i])/PrePeriod;
           }
         PR[i]=MA[i]-Ind[i];
         if(abs) PR[i]=MathAbs(PR[i]);
        }

      // Нормирование
      double max=PR[ArrayMaximum(PR,Window,i+WindowShift)];
      double min=PR[ArrayMinimum(PR,Window,i+WindowShift)];
      if(WindowMethod)
         for(n=Window; max-min<sens && n<=WindowLimit; n++) 
           {
            int in=i+n+WindowShift;
            max=MathMax(max,PR[in]);
            min=MathMin(min,PR[in]);
           }
      double x=(PR[i]-min)/MathMax((max-min),sn);
      if(Power!=1 && Power>0) x=MathPow(x,Power);
      NORM[i]=x;

      if(ToRange) // при сдвиге выборки убрать значения вне диап.0...1
        {NORM[i]=MathMax(NORM[i],0); NORM[i]=MathMin(NORM[i],1);}

      if(abs) // вывод нормирования со знаком 
         if(Em) // если объем или ATR
           {if(Close[i]>SIGN[i+3]) NP[i]=NORM[i]; else NP[i]=-NORM[i];}
      else // если ст.дев.
        {if(Close[i]>MA[i+3]) NP[i]=NORM[i]; else NP[i]=-NORM[i];}

      // Сглаживание .
      if(Signal==1) SM[i]=NORM[i+SignalShift];
      else
      if(MAtypeS) // EMA
      SM[i]=SignalK*NORM[i+SignalShift]+(1-SignalK)*SM[i+1];
      else 
        { // SMA
         sh=i+SignalShift+Signal;
         ma=SM[i+1]*Signal-NORM[sh];
         SM[i]=(ma+NORM[i+SignalShift])/Signal;
        }
     }
//----
   return(0);
  }
//----------------------------------------------------  
// ф-я дополнительной инициализации
int reinit()
  {
   ArrayInitialize(Input,0.0);
   ArrayInitialize(Ind,0.0);
   ArrayInitialize(PR,0.0);
   ArrayInitialize(NORM,0.0);
   ArrayInitialize(SM,0.0);
   ArrayInitialize(MA,0.0);
   ArrayInitialize(NP,0.0);
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double Price(int ApplPrice,int i) 
  {
   switch(ApplPrice) 
     {
      case 0: return(Close[i]);
      case 1: return(Open[i]);
      case 2: return(High[i]);
      case 3: return(Low[i]);
      case 4: return((High[i]+Low[i])/2);
      case 5: return((High[i]+Low[i]+Close[i])/3);
      case 6: return((High[i]+Low[i]+2*Close[i])/4);
      default: return(Close[i]);
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string _Price() 
  {
   switch(ApplPrice) 
     {
      case 0: return("");
      case 1: return("O");
      case 2: return("H");
      case 3: return("L");
      case 4: return("M");
      case 5: return("T");
      case 6: return("W");
      default: return("");
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void EmBuff()
  {
   static int NewSize;
   if(NewSize==Bars) return;
   NewSize=Bars;
   ArraySetAsSeries(SIGN,0); ArrayResize(SIGN,NewSize); ArraySetAsSeries(SIGN,1);
  }

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