Plugins

Hello,

I need the following plugins:
- JurikJMA.
- Typ.
- Gp_CreateStop.
- JurikRSX.



Someone can send me. Thank you very much.

Greetings

hi jose mary

i am having jurik afls..i am uploading some of them.
see if they r d ones needed by u.

Also please tell where u r using them??
As buddying traders will get an idea

Also i had uploaded metatrader code of ansatsu trading system.Did u get some time to convert it into amibroker?

Do give reply

Regards
Anurag

This is what you have attached :

_SECTION_BEGIN("JMA");
Length=Param( "Length ", 10, 0, 500);
Phase=Param( "Phase", 0, -100, 100);

Plot( JurikJMA( Close, 3, Phase), _DEFAULT_NAME(), colorWhite, styleThick );
Plot( JurikJMA( Close, 5, Phase), _DEFAULT_NAME(), colorBlue, styleThick );
Plot( JurikJMA( Close, 8, Phase), _DEFAULT_NAME(), colorBlue, styleThick );
Plot( JurikJMA( Close, 10, Phase), _DEFAULT_NAME(), colorBlue, styleThick );
Plot( JurikJMA( Close, 12, Phase), _DEFAULT_NAME(), colorBlue, styleThick );
Plot( JurikJMA( Close, 15, Phase), _DEFAULT_NAME(), colorYellow, styleThick );

_SECTION_END();

Its of no use unless one has the Formula for JurikJMA!!!

sorry
here is the code 4 jurik ma

_SECTION_BEGIN("Jurik MA");

#pragma nocache


function IntPortion (Paramet) {
return IIf (Paramet > 0,floor (Paramet),ceil (Paramet));
};

//---- input parameters
Length=Param("Length",14,0,100);
Phase=Param("Phase",0,-100,100);
function JJMA(Array,Length,Phase)
{
//---- buffers
fC0Buffer=fC8Buffer=fA8Buffer=0;
JMAValueBuffer=C;
JMAValue=0;
loopCriteria=cycleDelta=cycleLimit=counterA=counterB=JMATempValue=0;
//+------------------------------------------------------------------+
//| JMA initFlagization function |
//+------------------------------------------------------------------+
ring2=0;
ring1=0;
buffer=0;
//---- initial part
limitValue = 63;
startValue = 64;
//----
for (i = 0; i <= limitValue; i++) list = -1000000;
for (i = startValue; i <= 127; i++) list = 1000000;
//----
initFlag = True;
lengthParam=IIf (Length < 1.0000000002,0.0000000001,(Length - 1) / 2.0);
//----
if (Phase < -100) phaseParam = 0.5;
else if (Phase > 100) phaseParam = 2.5;
else phaseParam = Phase / 100.0 + 1.5;
//----
logParam = log (sqrt (lengthParam)) / log (2.0);
//----
logParam=IIf ((logParam + 2.0) < 0,0,logParam + 2.0);
//----
sqrtParam = sqrt(lengthParam) * logParam;
lengthParam = lengthParam * 0.9;
lengthDivider = lengthParam / (lengthParam + 2.0);
//----

//+------------------------------------------------------------------+
//| JMA iteration function |
//+------------------------------------------------------------------+
//---- main cycle
loopParam=0;

for (shift =0 ; shift <=BarCount-1; shift++) {
series = Close [shift];

if (loopParam < 61) {
loopParam++;
buffer [loopParam] = series;
}
if (loopParam > 30) {
if (initFlag) {
initFlag = False;

diffFlag = 0;
for (i = 1; i <= 29; i++) {
if (buffer [i + 1] != buffer ) diffFlag = 1;
}
highLimit = diffFlag * 30;

if (highLimit == 0) paramB = series;
else paramB = buffer[1];

paramA = paramB;
if (highLimit > 29) highLimit = 29;
} else
highLimit = 0;
//---- big cycle
for (i = highLimit; i >= 0; i--) {
if (i == 0) sValue = series; else sValue = buffer [31 - i];

if (abs (sValue - paramA) > abs (sValue - paramB)) absValue = abs(sValue - paramA); else absValue = abs(sValue - paramB);
dValue = absValue + 0.0000000001; //1.0e-10;

if (counterA <= 1) counterA = 127; else counterA--;
if (counterB <= 1) counterB = 10; else counterB--;
if (cycleLimit < 128) cycleLimit++;
cycleDelta = cycleDelta +(dValue - ring2 [counterB]);
ring2 [counterB] = dValue;
if (cycleLimit > 10) highDValue = cycleDelta / 10.0; else highDValue = cycleDelta / cycleLimit;

if (cycleLimit > 127) {
dValue = ring1 [counterA];
ring1 [counterA] = highDValue;
s68 = 64; s58 = s68;
while (s68 > 1) {
if (list [s58] < dValue) {
s68 = s68 / 2.0;
s58 = s58 + s68;
} else
if (list [s58] <= dValue) {
s68 = 1;
} else {
s68 = s68 / 2.0;
s58 = s58 - s68;
}
}
} else {
ring1 [counterA] = highDValue;
if ((limitValue + startValue) > 127) {
startValue--;
s58 = startValue;
} else {
limitValue++;
s58 = limitValue;
}
if (limitValue > 96) s38 = 96; else s38 = limitValue;
if (startValue < 32) s40 = 32; else s40 = startValue;
}
//----
s68 = 64;
s60 = s68;
while (s68 > 1) {
if (list [s60] >= highDValue) {
if (list [s60 - 1] <= highDValue) {
s68 = 1;
}
else {
s68 = s68 / 2.0;
s60 = s60 - s68;
}
}
else {
s68 = s68 / 2.0;
s60 = s60 + s68;
}
if ((s60 == 127) && (highDValue > list[127])) s60 = 128;
}
if (cycleLimit > 127) {
if (s58 >= s60) {
if (((s38 + 1) > s60) && ((s40 - 1) < s60))
lowDValue = lowDValue + highDValue;
else if ((s40 > s60) && ((s40 - 1) < s58))
lowDValue = lowDValue + list [s40 - 1];
}
else if (s40 >= s60) {
if (((s38 + 1) < s60) && ((s38 + 1) > s58))
lowDValue = lowDValue + list[s38 + 1];
}
else if ((s38 + 2) > s60)
lowDValue = lowDValue + highDValue;
else if (((s38 + 1) < s60) && ((s38 + 1) > s58))
lowDValue = lowDValue + list[s38 + 1];

if (s58 > s60) {
if (((s40 - 1) < s58) && ((s38 + 1) > s58))
lowDValue = lowDValue - list [s58];
else if ((s38 < s58) && ((s38 + 1) > s60))
lowDValue = lowDValue - list [s38];
}
else {
if (((s38 + 1) > s58) && ((s40 - 1) < s58))
lowDValue = lowDValue - list [s58];
else if ((s40 > s58) && (s40 < s60))
lowDValue = lowDValue - list [s40];
}
}
if (s58 <= s60) {
if (s58 >= s60) list[s60] = highDValue; else {
for (j = s58 + 1; j <= (s60 - 1); j++) {
list [j - 1] = list[j];
}
list [s60 - 1] = highDValue;
}
} else {
for (j = s58 - 1; j >= s60; j--) {
list [j + 1] = list [j];
}
list [s60] = highDValue;
}

if (cycleLimit <= 127) {
lowDValue = 0;
for (j = s40; j <= s38; j++) {
lowDValue = lowDValue + list[j];
}
}
//----
if ((loopCriteria + 1) > 31) loopCriteria = 31; else loopCriteria++;
JMATempValue=sqrtDivider = sqrtParam / (sqrtParam + 1.0);

if (loopCriteria <= 30) {
if (sValue - paramA > 0) paramA = sValue; else paramA = sValue - (sValue - paramA) * sqrtDivider;
if (sValue - paramB < 0) paramB = sValue; else paramB = sValue - (sValue - paramB) * sqrtDivider;
JMATempValue = series;

if (loopCriteria == 30) {
fC0Buffer [shift] = series;

if (ceil(sqrtParam) >= 1) intPart = ceil(sqrtParam); else intPart = 1;
leftInt = IntPortion (intPart);
if (floor(sqrtParam) >= 1) intPart = floor(sqrtParam); else intPart = 1;
rightPart = IntPortion (intPart);

if (leftInt == rightPart) dValue = 1.0;
else
dValue = (sqrtParam - rightPart) / (leftInt - rightPart);

if (rightPart <= 29) upShift = rightPart; else upShift = 29;
if (leftInt <= 29) dnShift = leftInt; else dnShift = 29;
fA8Buffer [shift] = (series - buffer [loopParam - upShift]) * (1 - dValue) / rightPart + (series - buffer[loopParam - dnShift]) * dValue / leftInt;
}
} else {

dValue = lowDValue / (s38 - s40 + 1);
if (0.5 <= logParam - 2.0) powerValue = logParam - 2.0;
else powerValue = 0.5;

if (logParam >= (absValue/dValue)^powerValue) dValue = (absValue/dValue)^powerValue; else dValue = logParam;
if (dValue < 1) dValue = 1;

powerValue = sqrtDivider^(sqrt (dValue));
if (sValue - paramA > 0) paramA = sValue; else paramA = sValue - (sValue - paramA) * powerValue;
if (sValue - paramB < 0) paramB = sValue; else paramB = sValue - (sValue - paramB) * powerValue;
}
}
// ---- end of big cycle
if (loopCriteria > 30) {
JMATempValue = JMAValueBuffer [shift - 1];
powerValue = lengthDivider^dValue;
squareValue = powerValue^2;

fC0Buffer [shift] = (1 - powerValue) * series + powerValue * fC0Buffer [shift - 1];
fC8Buffer [shift] = (series - fC0Buffer [shift]) * (1 - lengthDivider) + lengthDivider * fC8Buffer [shift - 1];

fA8Buffer [shift] = (phaseParam * fC8Buffer [shift] + fC0Buffer [shift] - JMATempValue) *
(powerValue * (-2.0) + squareValue + 1) + squareValue * fA8Buffer [shift - 1];
JMATempValue = JMATempValue + fA8Buffer [shift];
}
JMAValue = JMATempValue;
}
if (loopParam <= 30) JMAValue = C[BarCount-1];
JMAValueBuffer [shift] = JMAValue;
//---- End of main cycle
}
return JMAValueBuffer;
}
J=JJMA(C,Length,Phase);
Plot(J,"JJMA",5,1);
_SECTION_END();

i know its working..........one doubt rkkarnaniji........

jurik MA is developed by jurik research and they claim it to have very less lag and robust against gaps....but the thing is that when i use it in ma crossovers it gives large numbers of whipsaws though entry and exits r fast.

So is it ok if one goes for old EMAs only for ma crossovers??

Do u use ma crossovers?? As far as what i experience is that entry is ok but for exits are bit late....can we use trailing stop loss to stop giving away the profit

Please give advice

Regards
Anurag

Thank you very much.