Slope Entry Points

ÿþ//------------------------------------------------------------------

//------------------------------------------------------------------

#property indicator_chart_window

#property indicator_buffers 8

#property indicator_plots   4

#property indicator_type1 DRAW_ARROW

#property indicator_type2 DRAW_ARROW

#property indicator_type3 DRAW_ARROW

#property indicator_type4 DRAW_ARROW

#property indicator_color1 clrDeepSkyBlue

#property indicator_color2 clrTomato

#property indicator_color3 clrDeepSkyBlue

#property indicator_color4 clrTomato

#property indicator_width1 2

#property indicator_width2 2

#property indicator_width3 2

#property indicator_width4 2

//

//

//



input double             T3Period        = 25;             // T3 period

input double             T3Hot           = 0.7;            // T3 volume factor

   enum enT3Type

   {

      t3_tillson  = (int)true,  // Tim Tillson way of calculation

      t3_fulksmat = int(false), // Fulks/Matulich way of calculation

   };

input enT3Type           T3Original      = t3_fulksmat;    // T3 calculation mode

input ENUM_APPLIED_PRICE T3Price         = PRICE_CLOSE;    // Average price

      enum chgColor

         {

            chg_onSlope,  // change color on slope change

            chg_onLevel,  // Change color on outer levels cross

            chg_onMiddle  // Change color on middle level cross

         };

input chgColor           ColorOn         = chg_onLevel;    // Color change on :

input int                FlPeriod        = 25;             // Period for finding floating levels

input double             FlUp            = 90;             // Upper level %

input double             FlDown          = 10;             // Lower level %



//

//

//



double t3[],mid[],fup[],fdn[];

double ext_dot_buy[];

double ext_dot_sell[];

double ext_arrow_buy[];

double ext_arrow_sell[];



//------------------------------------------------------------------

//

//------------------------------------------------------------------

//

//

//



int OnInit()

{

   SetIndexBuffer(0, ext_dot_buy, INDICATOR_DATA);

   SetIndexBuffer(1, ext_dot_sell, INDICATOR_DATA);

   SetIndexBuffer(2, ext_arrow_buy, INDICATOR_DATA);

   SetIndexBuffer(3, ext_arrow_sell, INDICATOR_DATA);



   SetIndexBuffer(4,fup,INDICATOR_CALCULATIONS);

   SetIndexBuffer(5,fdn,INDICATOR_CALCULATIONS);

   SetIndexBuffer(6,mid,INDICATOR_CALCULATIONS);

   SetIndexBuffer(7,t3 ,INDICATOR_CALCULATIONS);

   

   PlotIndexSetInteger(0, PLOT_ARROW, 174);

   PlotIndexSetInteger(1, PLOT_ARROW, 174);

   PlotIndexSetInteger(2, PLOT_ARROW, 233);

   PlotIndexSetInteger(3, PLOT_ARROW, 234);

   

      //

      //

      //

      

   IndicatorSetString(INDICATOR_SHORTNAME,"T3 floating levels ("+(string)T3Period+")");

   return(INIT_SUCCEEDED);

}



//------------------------------------------------------------------

//

//------------------------------------------------------------------

//

//

//



#define _setPrice(_priceType,_target,_index) { \

   switch(_priceType) \

   { \

      case PRICE_CLOSE    : _target = close[_index];                                              break; \

      case PRICE_OPEN     : _target = open[_index];                                               break; \

      case PRICE_HIGH     : _target = high[_index];                                               break; \

      case PRICE_LOW      : _target = low[_index];                                                break; \

      case PRICE_MEDIAN   : _target = (high[_index]+low[_index])/2.0;                             break; \

      case PRICE_TYPICAL  : _target = (high[_index]+low[_index]+close[_index])/3.0;               break; \

      case PRICE_WEIGHTED : _target = (high[_index]+low[_index]+close[_index]+close[_index])/4.0; break; \

      default : _target = 0; \

   }}



//

//

//



int OnCalculate(const int rates_total,

                const int prev_calculated,

                const datetime& time[],

                const double& open[],

                const double& high[],

                const double& low[],

                const double& close[],

                const long& tick_volume[],

                const long& volume[],

                const int& spread[]) { 

   int limit = (prev_calculated>0) ? prev_calculated-1 : 0;

   

   for(int i=limit; i<rates_total && !_StopFlag; i++) {

      double price; _setPrice(T3Price,price,i);

      t3[i] = iT3(price,T3Period,T3Hot,T3Original,i,rates_total);

      int _start = i-FlPeriod+1; if (_start<0) _start=0;

      

      double hi = t3[ArrayMaximum(t3,_start,FlPeriod)];

      double lo = t3[ArrayMinimum(t3,_start,FlPeriod)];

      double rn = hi-lo;

      fup[i] = lo+rn*FlUp  /100.0;

      fdn[i] = lo+rn*FlDown/100.0;

      mid[i] = (fup[i]+fdn[i])/2;

   }

   double shift_coef = 0.4;

   for(int i=limit; i<rates_total && !_StopFlag; i++) {

      if(i<=0) continue;

      double range = fup[i] - fdn[i];

      // sell dot

      if(t3[i] < fup[i] && t3[i-1] >= fup[i-1]) 

         ext_dot_sell[i] = high[i] + range*shift_coef;

      else

         ext_dot_sell[i] = EMPTY_VALUE;

      // sell arrow

      if(t3[i] < fdn[i] && t3[i-1] >= fdn[i-1]) 

         ext_arrow_sell[i] = high[i] + range*shift_coef;

      else

         ext_arrow_sell[i] = EMPTY_VALUE;

      // buy dot

      if(t3[i] > fdn[i] && t3[i-1] <= fdn[i-1]) 

         ext_dot_buy[i] = low[i] - range*shift_coef;

      else

         ext_dot_buy[i] = EMPTY_VALUE;

      // buy arrow

      if(t3[i] > fup[i] && t3[i-1] <= fup[i-1]) 

         ext_arrow_buy[i] = low[i] - range*shift_coef;

      else

         ext_arrow_buy[i] = EMPTY_VALUE;

   

   }

   return(rates_total);

}



//------------------------------------------------------------------

//

//------------------------------------------------------------------

//

//

//



#define _maInstances 1

double iT3(double value, double period, double volumeFactor, bool original, int r, int bars, int instanceNo=0) {

   struct sCoeffStruct

         {

            double volumeFactor;

            double volumePlus;

            double period;

            double alpha;

            double result;

            bool   original;

               sCoeffStruct() : period(EMPTY_VALUE) {}

         };

   static sCoeffStruct m_coeffs[_maInstances];

   struct sDataStruct

         {

            double val[7];

         };

   struct sWorkStruct { sDataStruct data[_maInstances]; };

   static sWorkStruct m_array[];

   static int         m_arraySize = -1;

   if (m_arraySize<=bars) m_arraySize = ArrayResize(m_array,bars+500,2000);

   if (m_coeffs[instanceNo].period       != (period)  ||

       m_coeffs[instanceNo].volumeFactor != volumeFactor) {

      m_coeffs[instanceNo].period       = (period > 1) ? period : 1;

      m_coeffs[instanceNo].alpha        = (original) ? 2.0/(1.0+m_coeffs[instanceNo].period) : 2.0/(2.0+(m_coeffs[instanceNo].period-1.0)/2.0);

      m_coeffs[instanceNo].volumeFactor = (volumeFactor>0) ? (volumeFactor>1) ? 1 : volumeFactor : DBL_MIN;

      m_coeffs[instanceNo].volumePlus   = (volumeFactor+1);

   }



   if (r>0) {

      #define _gdema(_part1,_part2) (m_array[r].data[instanceNo].val[_part1]*m_coeffs[instanceNo].volumePlus - m_array[r].data[instanceNo].val[_part2]*m_coeffs[instanceNo].volumeFactor)

      m_array[r].data[instanceNo].val[0] = m_array[r-1].data[instanceNo].val[0]+m_coeffs[instanceNo].alpha*(value                             -m_array[r-1].data[instanceNo].val[0]);

      m_array[r].data[instanceNo].val[1] = m_array[r-1].data[instanceNo].val[1]+m_coeffs[instanceNo].alpha*(m_array[r].data[instanceNo].val[0]-m_array[r-1].data[instanceNo].val[1]);

      m_array[r].data[instanceNo].val[2] = m_array[r-1].data[instanceNo].val[2]+m_coeffs[instanceNo].alpha*(_gdema(0,1)                       -m_array[r-1].data[instanceNo].val[2]);

      m_array[r].data[instanceNo].val[3] = m_array[r-1].data[instanceNo].val[3]+m_coeffs[instanceNo].alpha*(m_array[r].data[instanceNo].val[2]-m_array[r-1].data[instanceNo].val[3]);

      m_array[r].data[instanceNo].val[4] = m_array[r-1].data[instanceNo].val[4]+m_coeffs[instanceNo].alpha*(_gdema(2,3)                       -m_array[r-1].data[instanceNo].val[4]);

      m_array[r].data[instanceNo].val[5] = m_array[r-1].data[instanceNo].val[5]+m_coeffs[instanceNo].alpha*(m_array[r].data[instanceNo].val[4]-m_array[r-1].data[instanceNo].val[5]);

      m_array[r].data[instanceNo].val[6] =                             _gdema(4,5);

      #undef _gdema

   }

   else   

      ArrayInitialize(m_array[r].data[instanceNo].val,value);

   return(m_array[r].data[instanceNo].val[6]);

}