pointandfiguretrend_v1.3ea 600+.mq5

???//+------------------------------------------------------------------+

#property indicator_separate_window
#property indicator_buffers   2
#property indicator_color1    clrLimeGreen
#property indicator_color2    clrOrangeRed
#property indicator_width1    2
#property indicator_width2    2

#property indicator_level1    0

#property strict 

enum ENUM_PRICE
{
   close,               // Close
   open,                // Open
   high,                // High
   low,                 // Low
   median,              // Median
   typical,             // Typical
   weightedClose,       // Weighted Close
   medianBody,          // Median Body (Open+Close)/2
   average,             // Average (High+Low+Open+Close)/4
   trendBiased,         // Trend Biased
   haClose,             // Heiken Ashi Close
   haOpen,              // Heiken Ashi Open
   haHigh,              // Heiken Ashi High   
   haLow,               // Heiken Ashi Low
   haMedian,            // Heiken Ashi Median
   haTypical,           // Heiken Ashi Typical
   haWeighted,          // Heiken Ashi Weighted Close
   haMedianBody,        // Heiken Ashi Median Body
   haAverage,           // Heiken Ashi Average
   haTrendBiased        // Heiken Ashi Trend Biased   
};

enum ENUM_MA_MODE
{
   SMA,                 // Simple Moving Average
   EMA,                 // Exponential Moving Average
   Wilder,              // Wilder Exponential Moving Average
   LWMA,                // Linear Weighted Moving Average
   SineWMA,             // Sine Weighted Moving Average
   TriMA,               // Triangular Moving Average
   LSMA,                // Least Square Moving Average (or EPMA, Linear Regression Line)
   SMMA,                // Smoothed Moving Average
   HMA,                 // Hull Moving Average by A.Hull
   ZeroLagEMA,          // Zero-Lag Exponential Moving Average
   DEMA,                // Double Exponential Moving Average by P.Mulloy
   T3_basic,            // T3 by T.Tillson (original version)
   ITrend,              // Instantaneous Trendline by J.Ehlers
   Median,              // Moving Median
   GeoMean,             // Geometric Mean
   REMA,                // Regularized EMA by C.Satchwell
   ILRS,                // Integral of Linear Regression Slope
   IE_2,                // Combination of LSMA and ILRS
   TriMAgen,            // Triangular Moving Average generalized by J.Ehlers
   VWMA,                // Volume Weighted Moving Average
   JSmooth,             // M.Jurik's Smoothing
   SMA_eq,              // Simplified SMA
   ALMA,                // Arnaud Legoux Moving Average
   TEMA,                // Triple Exponential Moving Average by P.Mulloy
   T3,                  // T3 by T.Tillson (correct version)
   Laguerre,            // Laguerre filter by J.Ehlers
   MD,                  // McGinley Dynamic
   BF2P,                // Two-pole modified Butterworth filter by J.Ehlers
   BF3P,                // Three-pole modified Butterworth filter by J.Ehlers
   SuperSmu,            // SuperSmoother by J.Ehlers
   Decycler,            // Simple Decycler by J.Ehlers
   eVWMA,               // Modified eVWMA
   EWMA,                // Exponential Weighted Moving Average
   DsEMA,               // Double Smoothed EMA
   TsEMA                // Triple Smoothed EMA
};   

#define pi 3.14159265358979323846  

input ENUM_PRICE        Price                =       close;       // Appplied to
input bool              UseHighLow           =       false;       // Use High/Low 
input double            BoxSize              =          10;       // Step Size in pips(if StepSize=0 and VoltyLength=0 then StepSize = HiLoRange*VoltyRatio/100)
input double            Multiplier           =           2;       // Reversal Multiplier 
input int               PreSmooth            =           1;       // PreSmoothing Period
input ENUM_MA_MODE      PreSmoothMode        =           0;       // PreSmoothing Method
input double            PnFLevel             =          10;       // PnF Level 
input bool              ShowWicks            =       false;       // Show wicks
input int               CountBars            =           0;       // Number of bars counted: 0-all bars 

double upTrend[];
double dnTrend[];
double pnfNumber[];
double pnfPrice[];
double trend[];
double mPrice[];
double hiPrice[];
double loPrice[];
double oPrice[];
double aPrice1[];
double hiPrice1[];
double loPrice1[];
double oPrice1[];

int      timeframe, cBars, draw_begin, ma_period, masize;
double   _point;
string   short_name, TF, IndicatorName;

int OnInit()
{
      // код доступен только после оплаты
   }

int start()
{
      // код доступен только после оплаты
   }

void _PnFChart(int limit)
{
   double pnfopen;

   for(int shift=limit;shift>=0;shift--) 
   {	
   if(shift > Bars - 2) continue;

   trend[shift] = trend[shift+1];
   trend[shift] = pnfChart(pnfPrice[shift],pnfopen,Price,BoxSize,Multiplier,UseHighLow,MathMin(Bars-ma_period-1,cBars),shift);

   if(pnfPrice[shift+1] <= 0) continue; 

   upTrend[shift]   = 0; 
   dnTrend[shift]   = 0;
   pnfNumber[shift] = pnfNumber[shift+1];

      if(trend[shift] > 0)
      {
         if(trend[shift+1] < 0) 
         {
         upTrend[shift]   = NormalizeDouble((pnfPrice[shift] - pnfPrice[shift+1])/_point,Digits); 
         pnfNumber[shift] = 1;
         }
         else 
         {
         upTrend[shift]   = NormalizeDouble(upTrend[shift+1] + (pnfPrice[shift] - pnfPrice[shift+1])/_point,Digits); 
         if(pnfPrice[shift] != pnfPrice[shift+1]) pnfNumber[shift]+= 1;
         }
      }
      else
      if(trend[shift] < 0)
      {
         if(trend[shift+1] > 0) 
         {
         dnTrend[shift]   = NormalizeDouble((pnfPrice[shift] - pnfPrice[shift+1])/_point,Digits); 
         pnfNumber[shift] =-1;
         }
         else 
         {
         dnTrend[shift] = NormalizeDouble(dnTrend[shift+1] + (pnfPrice[shift] - pnfPrice[shift+1])/_point,Digits);
         if(pnfPrice[shift] != pnfPrice[shift+1]) pnfNumber[shift]-= 1;
         }
      }
   }      
}   

int      dir[2];
double   upband[2], loband[2], pnfclose[2];
datetime pnfprevtime;

int pnfChart(double& close,double& open,int pricemode,double size,double mult,bool hilo,int cbars,int bar)
{
   int app_price;
   double value, hiprice, loprice;

   if(pnfprevtime != Time[bar])
   {
   upband[1]   = upband[0]; 
   loband[1]   = loband[0];    
   dir[1]      = dir[0]; 
   pnfprevtime = Time[bar]; 
   }

   if(pricemode < 10) app_price = Price; else app_price = 0;

   mPrice[bar]  = getPrice(app_price,bar);
   hiPrice[bar] = High[bar];
   loPrice[bar] = Low [bar]; 
   oPrice[bar]  = Open[bar];

   if(bar > MathMin(Bars-ma_period-1,cBars)) return(-1);

   aPrice1 [bar] = allAveragesOnArray(0,mPrice ,PreSmooth,PreSmoothMode,masize,MathMin(Bars-ma_period-1,cBars),bar);   
   hiPrice1[bar] = allAveragesOnArray(1,hiPrice,PreSmooth,PreSmoothMode,masize,MathMin(Bars-ma_period-1,cBars),bar);  
   loPrice1[bar] = allAveragesOnArray(2,loPrice,PreSmooth,PreSmoothMode,masize,MathMin(Bars-ma_period-1,cBars),bar);  
   oPrice1 [bar] = allAveragesOnArray(3,oPrice ,PreSmooth,PreSmoothMode,masize,MathMin(Bars-ma_period-1,cBars),bar);    

   if(Price > 9)
   {
   aPrice1[bar] = HeikenAshi(0,Price-10,aPrice1[bar],hiPrice1[bar],loPrice1[bar],oPrice1[bar],MathMin(Bars-ma_period-1,cBars),bar,hiPrice1[bar],loPrice1[bar]);
   }

   double step = size*_point;

   if(!hilo)
   {
   hiprice = NormalizeDouble(MathFloor(aPrice1[bar]/step)*step,Digits); 
   loprice = NormalizeDouble(MathCeil (aPrice1[bar]/step)*step,Digits);
   }
   else
   {
   hiprice = NormalizeDouble(MathFloor(hiPrice1[bar]/step)*step,Digits);
   loprice = NormalizeDouble(MathCeil (loPrice1[bar]/step)*step,Digits);
   }

   if(bar < MathMin(Bars-ma_period-1,cBars))
   {
   upband[0] = upband[1]; 
   loband[0] = loband[1];   
   dir[0]    = dir[1]; 

   if(dir[0] != 0) value = NormalizeDouble(mult*step,Digits); else value  = step;

      if(dir[0] > 0) 
      {
         if(hiprice > upband[0]) 
         {
         upband[0] = NormalizeDouble(hiprice,Digits); 
         loband[0] = NormalizeDouble(upband[0] - value,Digits);
         }
         else
         {
            if(loprice < NormalizeDouble(upband[0] - value,Digits)) 
            {
            dir[0] =-1; 
            loband[0] = NormalizeDouble(loprice,Digits);
            upband[0] = NormalizeDouble(loband[0] + value,Digits);
            }
         }
      }
      else
      if(dir[0] < 0)
      {
         if(loprice < loband[0])
         {   
         loband[0] = NormalizeDouble(loprice,Digits); 
         upband[0] = NormalizeDouble(loband[0] + value,Digits);
         }
         else
         {
            if(hiprice > NormalizeDouble(loband[0] + value,Digits)) 
            {
            dir[0] = 1; 
            upband[0] = NormalizeDouble(hiprice,Digits); 
            loband[0] = NormalizeDouble(upband[0] - value,Digits);
            }
         }
      }
   }    
   else
   if(bar == MathMin(Bars-ma_period-1,cBars))
   { 
      if(Close[bar] >= Open[bar]) 
      {
      dir[0] = 1; 
      upband[0] = hiprice;
      loband[0] = loprice;// - value;
      }
      else
      {
      dir[0] =-1;   
      loband[0] = loprice;
      upband[0] = hiprice;//loprice + value; 
      }  
   }

   if(dir[0] > 0) close = upband[0]; else close = loband[0]; 

   return(dir[0]);
}

int averageSize(int mode)
{   
   int arraysize;

   switch(mode)
   {
   case DEMA     : arraysize = 2; break;
   case T3_basic : arraysize = 6; break;
   case JSmooth  : arraysize = 5; break;
   case TEMA     : arraysize = 4; break;
   case T3       : arraysize = 6; break;
   case Laguerre : arraysize = 4; break;
   case DsEMA    : arraysize = 2; break;
   case TsEMA    : arraysize = 3; break;
   default       : arraysize = 0; break;
   }

   return(arraysize);
}

double   tmp[][4][2], ma[4][4];
datetime prevtime[4];  

double allAveragesOnArray(int index,double& price[],int period,int mode,int arraysize,int cbars,int bar)
{
   int i;
   double MA[4];  

   switch(mode) 
	{
	case EMA: case Wilder: case SMMA: case ZeroLagEMA: case DEMA: case T3_basic: case ITrend: case REMA: case JSmooth: case SMA_eq: case TEMA: case T3: case Laguerre: case MD: case BF2P: case BF3P: case SuperSmu: case Decycler: case eVWMA: case DsEMA: case TsEMA:

		if(prevtime[index] != Time[bar])
      {
      ma[index][3] = ma[index][2]; 
      ma[index][2] = ma[index][1]; 
      ma[index][1] = ma[index][0]; 

      if(arraysize > 0) for(i=0;i<arraysize;i++) tmp[i][index][1] = tmp[i][index][0];

      prevtime[index] = Time[bar]; 
      }

      if(mode == ITrend || mode == REMA || mode == SMA_eq || (mode >= BF2P && mode < eVWMA)) for(i=0;i<4;i++) MA[i] = ma[index][i]; 
	}

   switch(mode)
   {
   case EMA       : ma[index][0] = EMAOnArray(price[bar],ma[index][1],period,cbars,bar); break;
   case Wilder    : ma[index][0] = WilderOnArray(price[bar],ma[index][1],period,cbars,bar); break;  
   case LWMA      : ma[index][0] = LWMAOnArray(price,period,bar); break;
   case SineWMA   : ma[index][0] = SineWMAOnArray(price,period,bar); break;
   case TriMA     : ma[index][0] = TriMAOnArray(price,period,bar); break;
   case LSMA      : ma[index][0] = LSMAOnArray(price,period,bar); break;
   case SMMA      : ma[index][0] = SMMAOnArray(price,ma[index][1],period,cbars,bar); break;
   case HMA       : ma[index][0] = HMAOnArray(price,period,cbars,bar); break;
   case ZeroLagEMA: ma[index][0] = ZeroLagEMAOnArray(price,ma[index][1],period,cbars,bar); break;
   case DEMA      : ma[index][0] = DEMAOnArray(index,0,price[bar],period,1,cbars,bar); break;
   case T3_basic  : ma[index][0] = T3_basicOnArray(index,0,price[bar],period,0.7,cbars,bar); break;
   case ITrend    : ma[index][0] = ITrendOnArray(price,MA,period,cbars,bar); break;
   case Median    : ma[index][0] = MedianOnArray(price,period,cbars,bar); break;
   case GeoMean   : ma[index][0] = GeoMeanOnArray(price,period,cbars,bar); break;
   case REMA      : ma[index][0] = REMAOnArray(price[bar],MA,period,0.5,cbars,bar); break;
   case ILRS      : ma[index][0] = ILRSOnArray(price,period,cbars,bar); break;
   case IE_2      : ma[index][0] = IE2OnArray(price,period,cbars,bar); break;
   case TriMAgen  : ma[index][0] = TriMA_genOnArray(price,period,cbars,bar); break;
   case VWMA      : ma[index][0] = VWMAOnArray(price,period,bar); break;
   case JSmooth   : ma[index][0] = JSmoothOnArray(index,0,price[bar],period,1,cbars,bar); break;
   case SMA_eq    : ma[index][0] = SMA_eqOnArray(price,MA,period,cbars,bar); break;
   case ALMA      : ma[index][0] = ALMAOnArray(price,period,0.85,8,bar); break;
   case TEMA      : ma[index][0] = TEMAOnArray(index,price[bar],period,1,cbars,bar); break;
   case T3        : ma[index][0] = T3OnArray(index,0,price[bar],period,0.7,cbars,bar); break;
   case Laguerre  : ma[index][0] = LaguerreOnArray(index,price[bar],period,4,cbars,bar); break;
   case MD        : ma[index][0] = McGinleyOnArray(price[bar],ma[index][1],period,cbars,bar); break;
   case BF2P      : ma[index][0] = BF2POnArray(price,MA,period,cbars,bar); break;
   case BF3P      : ma[index][0] = BF3POnArray(price,MA,period,cbars,bar); break;
   case SuperSmu  : ma[index][0] = SuperSmuOnArray(price,MA,period,cbars,bar); break;
   case Decycler  : ma[index][0] = DecyclerOnArray(price,MA,period,cbars,bar); return(price[bar] - ma[index][0]); 
   case eVWMA     : ma[index][0] = eVWMAOnArray(price[bar],ma[index][1],period,cbars,bar); break;
   case EWMA      : ma[index][0] = EWMAOnArray(price,period,bar); break;
   case DsEMA     : ma[index][0] = DsEMAOnArray(index,price[bar],period,cbars,bar); break;
   case TsEMA     : ma[index][0] = TsEMAOnArray(index,price[bar],period,cbars,bar); break;
   default        : ma[index][0] = SMAOnArray(price,period,bar); break;
   }

   return(ma[index][0]);
}

double SMAOnArray(double& array[],int per,int bar)
{
   double sum = 0;
   for(int i=0;i<per;i++) sum += array[bar+i];

   return(sum/per);
}                

double EMAOnArray(double price,double prev,int per,int cbars,int bar)
{
   double ema;

   if(bar >= cbars) ema = price;
   else 
   ema = prev + 2.0/(1 + per)*(pri

Показано первые 50% кода (символов: 23999)