UniOscillator Indicator For MT5
The UniOscillator Indicator For MT5 is a momentum oscillator that is based on the Relative Strength Index (RSI), with colored oversold and overbought areas. The indicator color scheme may be modified in the input parameters.
Users can select color change either on slope change, or on outer levels cross, or on breach of middle line. There is also the option to choose from 22 different types of applied prices. This level of customization can prove to be helpful for traders who operate in multiple asset classes; with each market requiring an oscillator that is optimized to fittingly adapt to the inherent demand-supply dynamics of that particular market.
Partially Automated Trading Besides Your Day Job
Alerts In Real-Time When Divergences Occur
My Recommended MT4/MT5 Broker
Installing the UniOscillator Indicator For MT5
After you downloaded the indicator via the form above you need to unzip the zip-file. Then you need to copy the file Universal_oscillator.mq5 into the folder MQL5\Indicators of your MT5 installation. After that please restart MT5 and then you will be able to see the indicator in the list of indicators.
Parameters of the UniOscillator Indicator For MT5
The UniOscillator Indicator For MT5 has 5 parameters to configure.
input double BandEdge = 20; // Band edge
input enPrices Price = pr_close; // Price to use
input double LevelUp = 0.8; // Upper level
input double LevelDown = -0.8; // Lower level
input enColorOn ColorOn = cc_onLevels; // Color change :
Buffers of the UniOscillator Indicator For MT5
The UniOscillator Indicator For MT5 provides 9 buffers.
SetIndexBuffer(0,fill1 ,INDICATOR_DATA);
SetIndexBuffer(1,fill2 ,INDICATOR_DATA);
SetIndexBuffer(2,levelup,INDICATOR_DATA);
SetIndexBuffer(3,levelmi,INDICATOR_DATA);
SetIndexBuffer(4,leveldn,INDICATOR_DATA);
SetIndexBuffer(5,unio ,INDICATOR_DATA);
SetIndexBuffer(6,trend ,INDICATOR_COLOR_INDEX);
SetIndexBuffer(7,prices ,INDICATOR_CALCULATIONS);
SetIndexBuffer(8,peak ,INDICATOR_CALCULATIONS);
Main Parts Of The Code
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[])
{
for (int i=(int)MathMax(prev_calculated-1,0); i lt rates_total; i++)
{
prices[i] = getPrice(Price,open,close,high,low,i,rates_total);
if (i lt 2) { peak[i] = 0; continue; }
double whiteNoise = (prices[i]-prices[i-2])/2.0;
double filter = iSsm(whiteNoise,BandEdge,i,rates_total);
peak[i] = 0.991*peak[i-1];
if (MathAbs(filter) gt peak[i]) peak[i] = MathAbs(filter);
unio[i] = filter/peak[i];
levelup[i] = LevelUp;
levelmi[i] = 0;
leveldn[i] = LevelDown;
trend[i] = 0;
switch(ColorOn)
{
case cc_onLevels:
if (unio[i] gt levelup[i]) trend[i] = 1;
if (unio[i] lt leveldn[i]) trend[i] = 2;
break;
case cc_onMiddle:
if (unio[i] gt levelmi[i]) trend[i] = 1;
if (unio[i] lt levelmi[i]) trend[i] = 2;
break;
default :
if (i gt 0)
{
if (unio[i] gt unio[i-1]) trend[i] = 1;
if (unio[i] lt unio[i-1]) trend[i] = 2;
}
}
//
//
//
//
//
fill1[i] = unio[i];
fill2[i] = unio[i];
if (unio[i] gt levelup[i]) fill2[i] = levelup[i];
if (unio[i] lt leveldn[i]) fill2[i] = leveldn[i];
}
return(rates_total);
}
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
//
//
//
//
//
#define Pi 3.14159265358979323846264338327950288
double workSsm[][2];
#define _tprice 0
#define _ssm 1
double workSsmCoeffs[][4];
#define _speriod 0
#define _sc1 1
#define _sc2 2
#define _sc3 3
double iSsm(double price, double period, int i, int TotalBars, int instanceNo=0)
{
if (period lt =1) return(price);
if (ArrayRange(workSsm,0) !=TotalBars) ArrayResize(workSsm,TotalBars);
if (ArrayRange(workSsmCoeffs,0) lt (instanceNo+1)) ArrayResize(workSsmCoeffs,instanceNo+1);
if (workSsmCoeffs[instanceNo][_speriod] != period)
{
workSsmCoeffs[instanceNo][_speriod] = period;
double a1 = MathExp(-1.414*Pi/period);
double b1 = 2.0*a1*MathCos(1.414*Pi/period);
workSsmCoeffs[instanceNo][_sc2] = b1;
workSsmCoeffs[instanceNo][_sc3] = -a1*a1;
workSsmCoeffs[instanceNo][_sc1] = 1.0 - workSsmCoeffs[instanceNo][_sc2] - workSsmCoeffs[instanceNo][_sc3];
}
//
//
//
//
//
int s = instanceNo*2;
workSsm[i][s+_ssm] = price;
workSsm[i][s+_tprice] = price;
if (i gt 1)
{
workSsm[i][s+_ssm] = workSsmCoeffs[instanceNo][_sc1]*(workSsm[i][s+_tprice]+workSsm[i-1][s+_tprice])/2.0 +
workSsmCoeffs[instanceNo][_sc2]*workSsm[i-1][s+_ssm] +
workSsmCoeffs[instanceNo][_sc3]*workSsm[i-2][s+_ssm]; }
return(workSsm[i][s+_ssm]);
}
//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//
//
double workHa[][4];
double getPrice(int tprice, const double& open[], const double& close[], const double& high[], const double& low[], int i, int _bars, int instanceNo=0)
{
if (tprice gt =pr_haclose)
{
if (ArrayRange(workHa,0)!= _bars) ArrayResize(workHa,_bars);
//
//
//
//
//
double haOpen;
if (i gt 0)
haOpen = (workHa[i-1][instanceNo+2] + workHa[i-1][instanceNo+3])/2.0;
else haOpen = (open[i]+close[i])/2;
double haClose = (open[i] + high[i] + low[i] + close[i]) / 4.0;
double haHigh = MathMax(high[i], MathMax(haOpen,haClose));
double haLow = MathMin(low[i] , MathMin(haOpen,haClose));
if(haOpen lt haClose) { workHa[i][instanceNo+0] = haLow; workHa[i][instanceNo+1] = haHigh; }
else { workHa[i][instanceNo+0] = haHigh; workHa[i][instanceNo+1] = haLow; }
workHa[i][instanceNo+2] = haOpen;
workHa[i][instanceNo+3] = haClose;
//
//
//
//
//
switch (tprice)
{
case pr_haclose: return(haClose);
case pr_haopen: return(haOpen);
case pr_hahigh: return(haHigh);
case pr_halow: return(haLow);
case pr_hamedian: return((haHigh+haLow)/2.0);
case pr_hamedianb: return((haOpen+haClose)/2.0);
case pr_hatypical: return((haHigh+haLow+haClose)/3.0);
case pr_haweighted: return((haHigh+haLow+haClose+haClose)/4.0);
case pr_haaverage: return((haHigh+haLow+haClose+haOpen)/4.0);
case pr_hatbiased:
if (haClose gt haOpen)
return((haHigh+haClose)/2.0);
else return((haLow+haClose)/2.0);
case pr_hatbiased2:
if (haClose gt haOpen) return(haHigh);
if (haClose lt haOpen) return(haLow);
return(haClose);
}
}
//
//
//
//
//
switch (tprice)
{
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_medianb: return((open[i]+close[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);
case pr_tbiased:
if (close[i] gt open[i])
return((high[i]+close[i])/2.0);
else return((low[i]+close[i])/2.0);
case pr_tbiased2:
if (close[i] gt open[i]) return(high[i]);
if (close[i] lt open[i]) return(low[i]);
return(close[i]);
}
return(0);
}
