Leledc-SSRC Force Final NRP nmc [garry119].mq4
Leledc-SSRC Force Final NRP nmc [garry119].mq4 FOREX MetaTrader4 Indicators Download
Leledc-SSRC Force Final NRP nmc [garry119].mq4 download link will appear after 10 seconds.
Leledc-SSRC Force Final NRP nmc [garry119].mq4 Programming source code
#property indicator_separate_window
#property indicator_buffers 6
#property indicator_color1 Lime
#property indicator_width1 2
#property indicator_color2 Red
#property indicator_width2 2
#property indicator_color3 DodgerBlue
#property indicator_width3 1
#property indicator_color4 Magenta
#property indicator_width4 1
#property indicator_color5 White
#property indicator_width5 1
#property indicator_color6 White
#property indicator_width6 1
#property indicator_maximum 1.1
#property indicator_minimum -1.1
#property strict
//---- input parameters
//---- Snake
extern int SnakeRange =13;
extern int FilterPeriod =21;
extern double MartFiltr =2;
extern int PriceConst =6;
extern int MaPeriod=5;
extern int MaMode=3;
extern double LevelsCross=0.95;
extern int Countbars=300;
extern bool AlertOn=false;
extern int ArrowUp=108;
extern int ArrowDown=108;
//---- buffers
double SRCBuffer[];
double Axis[];
double Mart[];
double Ma[];
double Up[],Down[];
double Up2[],Down2[];
//---- SpearmanRankCorrelation
int rangeN = 14; // = 30 maximum
double R2[];
double multiply;
int PriceInt[];
int SortInt[];
bool TurnedUp = false;
bool TurnedDown = false;
int init() {
IndicatorDigits((int)MarketInfo(Symbol(),MODE_DIGITS));
IndicatorBuffers(8);
SetIndexBuffer(0,SRCBuffer);
SetIndexStyle(0,DRAW_LINE);
SetIndexBuffer(1,Ma);
SetIndexStyle(1,DRAW_LINE);
SetIndexBuffer(2,Up);
SetIndexStyle(2,DRAW_ARROW);
SetIndexBuffer(3,Down);
SetIndexStyle(3,DRAW_ARROW);
SetIndexArrow(2,ArrowUp);
SetIndexArrow(3,ArrowDown);
SetIndexBuffer(4,Up2);
SetIndexStyle(4,DRAW_ARROW);
SetIndexBuffer(5,Down2);
SetIndexStyle(5,DRAW_ARROW);
SetIndexBuffer(6,Axis);
SetIndexStyle(6,DRAW_NONE);
SetIndexBuffer(7,Mart);
SetIndexStyle(7,DRAW_NONE);
SetLevelValue(0,LevelsCross);
SetLevelValue(1,-LevelsCross);
SetLevelValue(2,0);
ArrayResize(R2,rangeN);
ArrayResize(PriceInt,rangeN);
ArrayResize(SortInt,rangeN);
IndicatorShortName(WindowExpertName()+"( SR:"+(string)SnakeRange+", FP:"+(string)FilterPeriod+", MA:"+(string)MaPeriod+" )");
multiply=MathPow(10,Digits);
return(0);
}
//+------------------------------------------------------------------+
int deinit() {
return(0);
}
//+------------------------------------------------------------------+
int start() {
SetIndexDrawBegin(0,Bars-Countbars);
SetIndexDrawBegin(1,Bars-Countbars);
SetIndexDrawBegin(2,Bars-Countbars);
SetIndexDrawBegin(3,Bars-Countbars);
SetIndexDrawBegin(4,Bars-Countbars);
SetIndexDrawBegin(5,Bars-Countbars);
int i,k,limit=MathMin(Countbars,Bars-1);
int LastSignal=0;
int counted_bars = IndicatorCounted();
if(counted_bars < 0) return(-1);
for(i=0;i=0;i--)
{
for(k=0;k 1.0) SRCBuffer[i]=1.0;
if(SRCBuffer[i]<-1.0) SRCBuffer[i]=-1.0;
}
for(i=limit;i>=0;i--) Ma[i]=iMAOnArray(SRCBuffer,0,MaPeriod,0,MaMode,i);
for(i=limit;i>=0;i--)
{
if (SRCBuffer[i]>Ma[i] && SRCBuffer[i]>-LevelsCross && SRCBuffer[i]<0&& Ma[i]<0&& i!=0 && LastSignal!=1)
{
LastSignal=1;
Up[i]=SRCBuffer[i];
Down[i]=EMPTY_VALUE;
if (AlertOn && i==1 && !TurnedUp )
{
Alert(WindowExpertName()+" is crossing UP on"+" "+Symbol()," ",(string)Period()+" "+"minute charts");
TurnedUp = true;
TurnedDown = false;
}
}
if (SRCBuffer[i]0&& Ma[i]>0&& i!=0 && LastSignal!=-1)
{
LastSignal=-1;
Down[i]=SRCBuffer[i];
Up[i]=EMPTY_VALUE;
if (AlertOn && i==1 &&!TurnedDown )
{
Alert(WindowExpertName()+" is crossing DOWN on"+" "+Symbol()," ",(string)Period()+" "+"minute charts");
TurnedUp =false ;
TurnedDown = true;
}
}
}
for(i=limit;i>=0;i--)
{
if (SRCBuffer[i]>Ma[i] && Ma[i]>-LevelsCross && SRCBuffer[i]<0&& Ma[i]<0&& i!=0 && LastSignal!=1)
{
LastSignal=1;
Up2[i]=SRCBuffer[i];
Down2[i]=EMPTY_VALUE;
}
else if (SRCBuffer[i]0&& Ma[i]>0&& i!=0 && LastSignal!=-1)
{
LastSignal=-1;
Down2[i]=SRCBuffer[i];
Up2[i]=EMPTY_VALUE;
}
}
return(0);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
void MartAxis(int Pos) { int SnakeWeight,i,w,ww,Shift;double SnakeSum;
switch(PriceConst) {
case 0:
Axis[Pos]=iMA(NULL,0,SnakeRange+1,0,MODE_LWMA,PRICE_CLOSE,Pos);
break;
case 1:
Axis[Pos]=iMA(NULL,0,SnakeRange+1,0,MODE_LWMA,PRICE_OPEN,Pos);
break;
case 2:
Axis[Pos]=iMA(NULL,0,SnakeRange+1,0,MODE_LWMA,PRICE_HIGH,Pos);
break;
case 3:
Axis[Pos]=iMA(NULL,0,SnakeRange+1,0,MODE_LWMA,PRICE_LOW,Pos);
break;
case 4:
Axis[Pos]=iMA(NULL,0,SnakeRange+1,0,MODE_LWMA,PRICE_MEDIAN,Pos);
break;
case 5:
Axis[Pos]=iMA(NULL,0,SnakeRange+1,0,MODE_LWMA,PRICE_TYPICAL,Pos);
break;
case 6:
Axis[Pos]=iMA(NULL,0,SnakeRange+1,0,MODE_LWMA,PRICE_WEIGHTED,Pos);
break;
default:
Axis[Pos]=iMA(NULL,0,SnakeRange+1,0,MODE_LWMA,PRICE_WEIGHTED,Pos);
break; }
for(Shift=Pos+SnakeRange+2;Shift>Pos;Shift--) { SnakeSum=0.0;
SnakeWeight=0; i=0; w=Shift+SnakeRange; ww=Shift-SnakeRange;
if(ww=Shift) { i++; SnakeSum=SnakeSum+i*SnakePrice(w);
SnakeWeight=SnakeWeight+i; w--; }
while(w>=ww) { i--; SnakeSum=SnakeSum+i*SnakePrice(w);
SnakeWeight=SnakeWeight+i; w--; }
Axis[Shift]=SnakeSum/SnakeWeight; } return; }
//----
double SnakePrice(int Shift) {
switch(PriceConst) {
case 0: return(Close[Shift]);
case 1: return(Open[Shift]);
case 2: return(High[Shift]);
case 3: return(Low[Shift]);
case 4: return((High[Shift]+Low[Shift])/2);
case 5: return((Close[Shift]+High[Shift]+Low[Shift])/3);
case 6: return((2*Close[Shift]+High[Shift]+Low[Shift])/4);
default: return(Close[Shift]); } }
//+------------------------------------------------------------------+
void SmoothOverMart(int Shift) { double t,b;
t=Axis[ArrayMaximum(Axis,FilterPeriod,Shift)];
b=Axis[ArrayMinimum(Axis,FilterPeriod,Shift)];
Mart[Shift]=(2*(2+MartFiltr)*Axis[Shift]-(t+b))/2/(1+MartFiltr);
return; }
//+------------------------------------------------------------------+
//| calculate RSP function |
//+------------------------------------------------------------------+
double SpearmanRankCorrelation(double& Ranks[], int N)
{
//----
double res,z2=0;
int i;
for(i = 0; i < N; i++)
{
z2 += MathPow(Ranks[i] - i - 1, 2);
}
res = 1 - 6*z2 / (MathPow(N,3) - N);
//----
return(res);
}
//+------------------------------------------------------------------+
//| Ranking array of prices function |
//+------------------------------------------------------------------+
void RankPrices(int& InitialArray[])
{
//----
int i, k, m, dublicat, counter, etalon;
double dcounter, averageRank;
double TrueRanks[];
ArrayResize(TrueRanks, rangeN);
ArrayCopy(SortInt, InitialArray);
for(i = 0; i < rangeN; i++)
TrueRanks[i] = i + 1;
// if(direction)
ArraySort(SortInt, 0, 0, MODE_DESCEND);
// else
// ArraySort(SortInt, 0, 0, MODE_ASCEND);
for(i = 0; i < rangeN-1; i++)
{
if(SortInt[i] != SortInt[i+1])
continue;
dublicat = SortInt[i];
k = i + 1;
counter = 1;
averageRank = i + 1;
while(k < rangeN)
{
if(SortInt[k] == dublicat)
{
counter++;
averageRank += k + 1;
k++;
}
else
break;
}
dcounter = counter;
averageRank = averageRank / dcounter;
for(m = i; m < k; m++)
TrueRanks[m] = averageRank;
i = k;
}
for(i = 0; i < rangeN; i++)
{
etalon = InitialArray[i];
k = 0;
while(k < rangeN)
{
if(etalon == SortInt[k])
{
R2[i] = TrueRanks[k];
break;
}
k++;
}
}
//----
return;
}
//+------------------------------------------------------------------+
/*
int Tma(int Tma){
int limit,j,k,i;
for (i=limit; i>=0; i--)
{
double sum = (rangeN+1)*iMA(NULL,0,1,0,MODE_SMA,0,i);
double sumw = (rangeN+1);
for(j=1, k=rangeN; j<=rangeN; j++, k--)
{
sum += k*iMA(NULL,0,1,0,MODE_SMA,0,i+j);
sumw += k;
if (j<=i)
{
sum += k*iMA(NULL,0,1,0,MODE_SMA,0,i-j);
sumw += k;
}
}
Tma = sum/sumw;
}
}*/
//+------------------------------------------------------------------+