JMASlope_002
Download script
This script is designed to calculate and visualize the "slope" or direction of a specific type of moving average known as the Jurik Moving Average (JMA). Instead of just showing the price average, this tool focuses on the rate of change—telling you how fast the trend is moving up or down.
Core Logic Overview
1. Trend Detection and Smoothing The script starts by processing price data to create a "Jurik Moving Average." Unlike standard moving averages, which often lag behind price movements, the JMA uses complex internal calculations (including logarithmic scaling and non-linear filters) to stay as close to the price action as possible while remaining smooth. It attempts to balance two competing goals: reducing noise (jitter) and minimizing delay (lag).
2. Dynamic Adaptation The logic includes a "Phase" and "Length" system. The script calculates internal parameters based on these inputs to adjust how much weight is given to recent price changes versus historical data. It essentially builds a mathematical model that adapts to the speed of the market; it remains steady during sideways consolidation but reacts quickly when a new trend emerges.
3. Slope Calculation (The Result) Once the JMA value is calculated for each point in time, the script compares the current value against the previous one:
- Upward Movement: If the current average value is higher than it was in the previous step, the script identifies this as an "UpSlope."
- Downward Movement: If the current average value is lower than the previous step, it identifies this as a "DownSlope."
4. Visual Representation The final output is displayed as two separate histograms in a sub-window:
- Green Histogram (UpSlope): Represents the positive momentum of the trend.
- Red Histogram (DownSlope): Represents the negative momentum of the trend.
Summary for the User
Think of this script as a "momentum speedometer." While a standard moving average tells you where the price is, this indicator shows you how hard the price is pushing in one direction. By looking at the height of the histograms, you can see the strength of the current trend: taller bars indicate a stronger push in that direction, while smaller bars suggest the trend is losing steam or flattening out.
10
Views
0
Downloads
0
Favorites
JMASlope_002
//+------------------------------------------------------------------+
//| JMASlope.mq4 |
//| Copyright © 2005, TrendLaboratory Ltd. |
//| http://finance.groups.yahoo.com/group/TrendLaboratory |
//| Thanks to Weld, Jurik Research http://weld.torguem.net|
//+------------------------------------------------------------------+
#property copyright "Copyright © 2005, TrendLaboratory Ltd."
#property link "http://finance.groups.yahoo.com/group/TrendLaboratory"
//----
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_color1 Green
#property indicator_color2 Red
//---- input parameters
extern int Length=14;
extern int Phase =0;
//---- buffers
double UpBuffer [];
double DnBuffer [];
double JMAValueBuffer [];
double fC0Buffer [];
double fA8Buffer [];
double fC8Buffer [];
//---- temporary buffers
double list[128], ring1[128], ring2[11], buffer[62];
//---- bool flag
bool initFlag;
//---- integer vars
int limitValue, startValue, loopParam, loopCriteria;
int cycleLimit, highLimit, counterA, counterB;
//---- double vars
double cycleDelta, lowDValue, highDValue, absValue, paramA, paramB;
double phaseParam, logParam, JMAValue, series, sValue, sqrtParam, lengthDivider;
//---- temporary int variables
int s58, s60, s40, s38, s68;
//+------------------------------------------------------------------+
//| JMA initFlagization function |
//+------------------------------------------------------------------+
int init()
{
double lengthParam;
//---- 3 additional buffers are used for counting.
IndicatorBuffers(6);
//---- drawing settings
SetIndexStyle (0, DRAW_HISTOGRAM);
SetIndexStyle (1, DRAW_HISTOGRAM);
SetIndexDrawBegin(0, 30);
SetIndexDrawBegin(1, 30);
//---- 4 indicator buffers mapping
SetIndexBuffer (0, UpBuffer);
SetIndexBuffer (1, DnBuffer);
SetIndexBuffer (2, JMAValueBuffer);
SetIndexBuffer (3, fC0Buffer);
SetIndexBuffer (4, fA8Buffer);
SetIndexBuffer (5, fC8Buffer);
//---- initialize one buffer (neccessary)
ArrayInitialize (ring2, 0);
ArrayInitialize (ring1, 0);
ArrayInitialize (buffer, 0);
//---- name for DataWindow and indicator subwindow label
IndicatorShortName ("JMASlope(" + Length + "," + Phase + ")");
SetIndexLabel (0, "UpSlope");
SetIndexLabel (1, "DownSlope");
//---- initial part
limitValue=63;
startValue=64;
//----
for(int i=0; i<=limitValue; i++) list [i]=-1000000;
for(i=startValue; i<=127; i++) list [i]=1000000;
//----
initFlag =true;
if (Length < 1.0000000002) lengthParam=0.0000000001;
else lengthParam=(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=MathLog (MathSqrt (lengthParam))/MathLog (2.0);
//----
if (logParam + 2.0 < 0) logParam=0;
else logParam=logParam + 2.0;
//----
sqrtParam =MathSqrt(lengthParam) * logParam;
lengthParam =lengthParam * 0.9;
lengthDivider=lengthParam/(lengthParam + 2.0);
//----
return;
}
//+------------------------------------------------------------------+
//| JMA iteration function |
//+------------------------------------------------------------------+
int start()
{
//---- get already counted bars
int counted_bars=IndicatorCounted();
//---- check for possible errors
if (counted_bars < 0) return(-1);
int limit=Bars - counted_bars - 1;
//---- main cycle
for(int shift=limit; shift>=0; shift--)
{
series=Close [shift];
//----
if (loopParam < 61)
{
loopParam++;
buffer [loopParam]=series;
}
if (loopParam > 30)
{
if (initFlag)
{
initFlag=false;
//----
int diffFlag=0;
for(int i=1; i<=29; i++)
{
if (buffer [i + 1]!=buffer [i]) 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 (MathAbs (sValue - paramA) > MathAbs (sValue - paramB)) absValue=MathAbs(sValue - paramA); else absValue=MathAbs(sValue - paramB);
double 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+=(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+=s68;
}
else
if (list [s58]<=dValue)
{
s68=1;
}
else
{
s68=s68/2.0;
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-=s68;
}
}
else
{
s68=s68/2.0;
s60+=s68;
}
if ((s60==127) && (highDValue > list[127])) s60=128;
}
if (cycleLimit > 127)
{
if (s58>=s60)
{
if (((s38 + 1) > s60) && ((s40 - 1) < s60))
lowDValue+=highDValue;
else if ((s40 > s60) && ((s40 - 1) < s58))
lowDValue+=list [s40 - 1];
}
else if (s40>=s60)
{
if (((s38 + 1) < s60) && ((s38 + 1) > s58))
lowDValue+=list[s38 + 1];
}
else if ((s38 + 2) > s60)
lowDValue+=highDValue;
else if (((s38 + 1) < s60) && ((s38 + 1) > s58))
lowDValue+=list[s38 + 1];
if (s58 > s60)
{
if (((s40 - 1) < s58) && ((s38 + 1) > s58))
lowDValue-=list [s58];
else if ((s38 < s58) && ((s38 + 1) > s60))
lowDValue-=list [s38];
}
else
{
if (((s38 + 1) > s58) && ((s40 - 1) < s58))
lowDValue-=list [s58];
else if ((s40 > s58) && (s40 < s60))
lowDValue-=list [s40];
}
}
if (s58<=s60)
{
if (s58>=s60) list[s60]=highDValue; else
{
for(int 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+=list[j];
}
}
//----
if ((loopCriteria + 1) > 31) loopCriteria=31; else loopCriteria++;
double 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;
int intPart;
//----
if (MathCeil(sqrtParam)>=1) intPart=MathCeil(sqrtParam); else intPart=1;
int leftInt=IntPortion (intPart);
if (MathFloor(sqrtParam)>=1) intPart=MathFloor(sqrtParam); else intPart=1;
int rightPart=IntPortion (intPart);
//----
if (leftInt==rightPart) dValue=1.0;
else
dValue=(sqrtParam - rightPart)/(leftInt - rightPart);
if (rightPart<=29) int upShift=rightPart; else upShift=29;
if (leftInt<=29) int dnShift=leftInt; else dnShift=29;
fA8Buffer [shift]=(series - buffer [loopParam - upShift]) * (1 - dValue)/rightPart + (series - buffer[loopParam - dnShift]) * dValue/leftInt;
}
}
else
{
double powerValue, squareValue;
//----
dValue=lowDValue/(s38 - s40 + 1);
if (0.5<=logParam - 2.0) powerValue=logParam - 2.0;
else powerValue=0.5;
if (logParam>=MathPow(absValue/dValue, powerValue)) dValue=MathPow (absValue/dValue, powerValue); else dValue=logParam;
if (dValue < 1) dValue=1;
//----
powerValue=MathPow (sqrtDivider, MathSqrt (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 =MathPow (lengthDivider, dValue);
squareValue =MathPow (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+=fA8Buffer [shift];
}
JMAValue=JMATempValue;
}
if (loopParam<=30) JMAValue=0;
JMAValueBuffer [shift]=JMAValue;
double rel=JMAValueBuffer [shift]-JMAValueBuffer [shift+1];
if(rel>=0)
{
UpBuffer[shift]=rel;
DnBuffer[shift]=0;
}
else
{
DnBuffer[shift]=rel;
UpBuffer[shift]=0;
}
//---- End of main cycle
}
return;
}
//+------------------------------------------------------------------+
int IntPortion (double param)
{
if (param > 0) return(MathFloor (param));
if (param < 0) return(MathCeil (param));
return(0.0);
}
//+------------------------------------------------------------------+
Comments