//+------------------------------------------------------------------+
//|                                                  TEST DSS-MTF.mq4 |
//+------------------------------------------------------------------+
#property copyright "Copyright © 201"
#property indicator_buffers 1
#property indicator_color1 Blue
#property indicator_separate_window
#property indicator_minimum 0
#property indicator_maximum 100

//---- input parameters
extern int eintTF = 0;
extern int eintStochPeriod = 5;
extern int eintAveragePeriod = 3;      
extern int eintMaxBars = 100;

//---- indicator buffers
double gadblDSS[];


//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
   IndicatorShortName( "^DSS-MTF(M" + eintTF + ")" );
   
   SetIndexBuffer( 0, gadblDSS );
      
   SetIndexStyle( 0,DRAW_LINE ); 
      
   SetIndexLabel( 0, "DSS MTF" );
    
   SetLevelValue( 0, 20 );
   SetLevelValue( 1, 80 );
   SetLevelStyle( STYLE_DOT, 1, White );
   
   return( 0 );
}

//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
{
   return( 0 );
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
{
   int counted_bars = IndicatorCounted();   
   if (counted_bars < 0) return (-1);
   if (counted_bars > 0) counted_bars--;
   int intLimit = Bars - counted_bars;
   
   if ( ( eintMaxBars > 0 ) && ( intLimit > eintMaxBars ) )  intLimit = eintMaxBars;
   
   double adblDSS[];      
   ArrayResize( adblDSS, MathMax( eintAveragePeriod, eintStochPeriod ) );
   ArraySetAsSeries( adblDSS, true );   
   
   for( int inx = intLimit; inx >= 0; inx-- )
   {
      ArrayInitialize( adblDSS, 0.0 );
      
      calcDSS( inx, adblDSS );
            
      gadblDSS[inx] = adblDSS[0];      

   }
   
  return( 0 );
}
  
//+------------------------------------------------------------------+
//| calcRSI                                                          |
//+------------------------------------------------------------------+ 
void calcDSS( int intChartShift, double& adblData[] )
{
   double adblHigh[], adblLow[], adblClose[], adblTempH[200], adblTempL[200], adblTempC[200], MitBuffer[];
   double HighRange, LowRange;
   double delta, MIT, DSS;
   double smooth_coefficient = 2.0 / (1.0 + eintAveragePeriod);
   
   int intUtfShift = iBarShift( Symbol(), eintTF, Time[intChartShift], false );
   
   ArraySetAsSeries( adblTempH, true );
   ArraySetAsSeries( adblTempL, true );
   ArraySetAsSeries( adblTempC, true );
   
   ArrayResize( MitBuffer,ArraySize( adblData ));
   ArraySetAsSeries( MitBuffer, true );
   
   
   ArrayCopySeries( adblHigh, MODE_HIGH, Symbol(), eintTF );
   ArrayCopySeries( adblLow, MODE_LOW, Symbol(), eintTF );
   ArrayCopySeries( adblClose, MODE_CLOSE, Symbol(), eintTF );
   ArrayCopy( adblTempH, adblHigh, 0, intUtfShift, ArraySize( adblTempH ) );
   ArrayCopy( adblTempL, adblLow, 0, intUtfShift, ArraySize( adblTempL ) );
   ArrayCopy( adblTempC, adblClose, 0, intUtfShift, ArraySize( adblTempC ) );
   
   adblTempH[0] = High[intChartShift];
   adblTempL[0] = Low[intChartShift];
   adblTempC[0] = Close[intChartShift];
        
   for ( int inx = ArraySize( adblData ) - 1; inx >= 0; inx-- )
   {   
      HighRange = adblTempH[ArrayMaximum(adblTempH,eintStochPeriod,inx)];
      LowRange = adblTempL[ArrayMinimum(adblTempL,eintStochPeriod,inx)];
      delta = adblTempC[inx] - LowRange;
      MIT = delta/(HighRange - LowRange)*100.0;
      MitBuffer[inx] = smooth_coefficient * (MIT - MitBuffer[inx+1]) + MitBuffer[inx+1];
   }

   for ( inx = ArraySize( adblData ) - 1; inx >= 0; inx-- )
   { 
      HighRange = MitBuffer[ArrayMaximum(MitBuffer, eintStochPeriod, inx)];
      LowRange = MitBuffer[ArrayMinimum(MitBuffer, eintStochPeriod, inx)];
      delta = MitBuffer[inx] - LowRange;
      DSS = delta/(HighRange - LowRange)*100.0;
      adblData[inx] = smooth_coefficient * (DSS - adblData[inx+1]) + adblData[inx+1];
   }
   
}