← К каталогу
Исходный код · ID 4931

absolute_strength_-_averages.mq5

Вы автор или правообладатель?

Сообщите нам, если считаете, что материал размещён без разрешения.

Краткий обзор

О программе

Absolute Strength — Averages — это пользовательский индикатор для MetaTrader 5, отображающий четыре линии в отдельном окне: сглаженные и сигнальные линии бычьей и медвежьей силы. Индикатор рассчитывает абсолютную силу цены двумя методами — на основе RSI или стохастика — и применяет выбранную скользящую среднюю для сглаживания результатов.

В основе расчёта лежит сравнение текущей цены с предыдущей: при RSI-методле используются модули и знак разницы цен, а при стохастическом методе — разница цены от минимума и максимума за заданный период. Затем значения бычьей и медвежьей силы сглаживаются двумя этапами усреднения, формируя основные и сигнальные линии.

Индикатор поддерживает 17 методов скользящих средних (SMA, EMA, DEMA, TEMA, SMMA, LWMA и другие), 8 типов цен и настраиваемые длины расчёта, сглаживания и сигнальной линии. Линии бычьей силы отрисованы зелёным, медвежьей — оранжевым; сигнальные линии выполнены пунктиром в соответствующих цветах.

Настройки программы

НастройкаОписание
Mode Метод расчёта абсолютной силы. RSI_method — расчёт на основе модулей разницы цен (аналог RSI). Stochastic_method — расчёт на основе разницы цены от максимума и минимума за период (аналог стохастика).
Length Количество баров, используемых для расчёта абсолютной силы. Определяет период анализа при выборе стохастического метода и период первичного усреднения.
Smooth Длина сглаживания основных линий. Определяет период первой скользящей средней, применяемой к значениям абсолютной силы перед расчётом сигнальных линий.
Signal Длина сглаживания сигнальных линий. Определяет период второй скользящей средней, применяемой к уже сглаженным значениям бычьей и медвежьей силы.
Price Тип цены, используемый в расчёте абсолютной силы. Доступны: Close, Open, High, Low, Median, Typical, Weighted и Average.
AvgMethod Метод скользящей средней, используемый для сглаживания значений абсолютной силы. Поддерживает 17 типов: SMA, EMA, двойная сглаженная EMA, DEMA, TEMA, SMMA, LWMA, PWMA, Alexander MA, VWMA, Hull MA, TMA, Sine WMA, линейная регрессия, IE/2, NonLag MA, ZeroLag EMA и Leader EMA.

Поиск по коду файла

#property indicator_separate_window
#property indicator_buffers 4
#property indicator_plots   4
#property indicator_label1  "Smooth bulls"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrLimeGreen
#property indicator_width1  2 
#property indicator_label2  "Smooth bears"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrOrange
#property indicator_width2  2
#property indicator_label3  "Signal bulls"
#property indicator_type3   DRAW_LINE
#property indicator_color3  clrLimeGreen
#property indicator_style3  STYLE_DOT
#property indicator_label4  "Signal bears"
#property indicator_type4   DRAW_LINE
#property indicator_color4  clrOrange
#property indicator_style4  STYLE_DOT

enum ENUM_AS_MODE
{
   RSI_method,        // Calculate absolute strength using RSI method
   Stochastic_method  // Calculate absolute strength using Stochastic method
};
enum enAverages
{
   avgSma,    // Simple moving average
   avgEma,    // Exponential moving average
   avgDsema,  // Double smoothed EMA
   avgDema,   // Double EMA
   avgTema,   // Tripple EMA
   avgSmma,   // Smoothed MA
   avgLwma,   // Linear weighted MA
   avgPwma,   // Parabolic weighted MA
   avgAlex,   // Alexander MA
   avgVwma,   // Volume weighted MA
   avgHull,   // Hull MA
   avgTma,    // Triangular MA
   avgSine,   // Sine weighted MA
   avgLsma,   // Linear regression value
   avgIe2,    // IE/2
   avgNlma,   // Non lag MA
   avgZlma,   // Zeo lag EMA
   avgLead    // Leader EMA
};
enum enPrices
{
   pr_close,      // Close
   pr_open,       // Open
   pr_high,       // High
   pr_low,        // Low
   pr_median,     // Median
   pr_typical,    // Typical
   pr_weighted,   // Weighted
   pr_average     // Average (high+low+oprn+close)/4
};

input ENUM_AS_MODE Mode      = RSI_method; // Calculation method
input int          Length    = 14;         // Calculation length
input int          Smooth    = 5;          // Smoothing length
input int          Signal    = 5;          // Signal smoothing length
input enPrices     Price     = pr_close;   // Price
input enAverages   AvgMethod = avgSmma;    // Averaging method

double SmthBulls[];
double SmthBears[];
double SigBulls[];
double SigBears[];

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

int totalBars;
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[])
{
      // код доступен только после оплаты
   }

double getPrice(enPrices price, const double& open[], const double& close[], const double& high[], const double& low[], int bars, int i)
{
   switch (price)
   {
      case pr_close:     return(close[i]);
      case pr_open:      return(open[i]);
      case pr_high:      return(high[i]);
      case pr_low:       return(low[i]);
      case pr_median:    return((high[i]+low[i])/2.0);
      case pr_typical:   return((high[i]+low[i]+close[i])/3.0);
      case pr_weighted:  return((high[i]+low[i]+close[i]+close[i])/4.0);
      case pr_average:   return((high[i]+low[i]+close[i]+open[i])/4.0);
   }
   return(0);
}

string methodNames[] = {"SMA","EMA","Double smoothed EMA","Double EMA","Tripple EMA","Smoothed MA","Linear weighted MA","Parabolic weighted MA","Alexander MA","Volume weghted MA","Hull MA","Triangular MA","Sine weighted MA","Linear regression","IE/2","NonLag MA","Zero lag EMA","Leader EMA"};
string getAverageName(int method)
{
   int max = ArraySize(methodNames)-1;
      method = (int)MathMax(MathMin(method,max),0); return(methodNames[method]);
}

#define _maWorkBufferx1 6
#define _maWorkBufferx2 12
#define _maWorkBufferx3 18

double iCustomMa(double price, double length, int mode, const long& Volume[], int r, int instanceNo=0)
{
   switch (mode)
   {
      case avgSma   : return(iSma(price,(int)length,r,instanceNo));
      case avgEma   : return(iEma(price,length,r,instanceNo));
      case avgDsema : return(iDsema(price,length,r,instanceNo));
      case avgDema  : return(iDema(price,length,r,instanceNo));
      case avgTema  : return(iTema(price,length,r,instanceNo));
      case avgSmma  : return(iSmma(price,length,r,instanceNo));
      case avgLwma  : return(iLwma(price,length,r,instanceNo));
      case avgPwma  : return(iLwmp(price,length,r,instanceNo));
      case avgAlex  : return(iAlex(price,length,r,instanceNo));
      case avgVwma  : return(iWwma(price,length,Volume,r,instanceNo));
      case avgHull  : return(iHull(price,length,r,instanceNo));
      case avgTma   : return(iTma(price,length,r,instanceNo));
      case avgSine  : return(iSineWMA(price,(int)length,r,instanceNo));
      case avgLsma  : return(iLinr(price,length,r,instanceNo));
      case avgIe2   : return(iIe2(price,length,r,instanceNo));
      case avgNlma  : return(iNonLagMa(price,length,r,instanceNo));
      case avgZlma  : return(iZeroLag(price,length,r,instanceNo));
      case avgLead  : return(iLeader(price,length,r,instanceNo));
      default : return(price);
   }
}

double workSma[][_maWorkBufferx2];
double iSma(double price, int period, int r, int instanceNo=0)
{
   if (ArrayRange(workSma,0)!= totalBars) ArrayResize(workSma,totalBars); instanceNo *= 2;

   int k;      
   workSma[r][instanceNo] = price;
   if (r>=period)
          workSma[r][instanceNo+1] = workSma[r-1][instanceNo+1]+(workSma[r][instanceNo]-workSma[r-period][instanceNo])/period;
   else { workSma[r][instanceNo+1] = 0; for(k=0; k<period && (r-k)>=0; k++) workSma[r][instanceNo+1] += workSma[r-k][instanceNo];  
          workSma[r][instanceNo+1] /= k; }
   return(workSma[r][instanceNo+1]);
}

double workEma[][_maWorkBufferx1];
double iEma(double price, double period, int r, int instanceNo=0)
{
   if (ArrayRange(workEma,0)!= totalBars) ArrayResize(workEma,totalBars);

   double alpha = 2.0 / (1.0+period);
          workEma[r][instanceNo] = workEma[r-1][instanceNo]+alpha*(price-workEma[r-1][instanceNo]);
   return(workEma[r][instanceNo]);
}

double workDsema[][_maWorkBufferx2];
#define _ema1 0
#define _ema2 1
double iDsema(double price, double period, int r, int instanceNo=0)
{
   if (ArrayRange(workDsema,0)!= totalBars) ArrayResize(workDsema,totalBars); instanceNo*=2;

   double alpha = 2.0 /(1.0+MathSqrt(period));
          workDsema[r][_ema1+instanceNo] = workDsema[r-1][_ema1+instanceNo]+alpha*(price                         -workDsema[r-1][_ema1+instanceNo]);
          workDsema[r][_ema2+instanceNo] = workDsema[r-1][_ema2+instanceNo]+alpha*(workDsema[r][_ema1+instanceNo]-workDsema[r-1][_ema2+instanceNo]);
   return(workDsema[r][_ema2+instanceNo]);
}

double workDema[][_maWorkBufferx2];
double iDema(double price, double period, int r, int instanceNo=0)
{
   if (ArrayRange(workDema,0)!= totalBars) ArrayResize(workDema,totalBars); instanceNo*=2;

   double alpha = 2.0 / (1.0+period);
          workDema[r][_ema1+instanceNo] = workDema[r-1][_ema1+instanceNo]+alpha*(price                        -workDema[r-1][_ema1+instanceNo]);
          workDema[r][_ema2+instanceNo] = workDema[r-1][_ema2+instanceNo]+alpha*(workDema[r][_ema1+instanceNo]-workDema[r-1][_ema2+instanceNo]);
   return(workDema[r][_ema1+instanceNo]*2.0-workDema[r][_ema2+instanceNo]);
}

double workTema[][_maWorkBufferx3];
#define _ema3 2
double iTema(double price, double period, int r, int instanceNo=0)
{
   if (ArrayRange(workTema,0)!= totalBars) ArrayResize(workTema,totalBars); instanceNo*=3;

   double alpha = 2.0 / (1.0+period);
          workTema[r][_ema1+instanceNo] = workTema[r-1][_ema1+instanceNo]+alpha*(price                        -workTema[r-1][_ema1+instanceNo]);
          workTema[r][_ema2+instanceNo] = workTema[r-1][_ema2+instanceNo]+alpha*(workTema[r][_ema1+instanceNo]-workTema[r-1][_ema2+instanceNo]);
          workTema[r][_ema3+instanceNo

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