JMA

Download script
Author: Weld
JMA

This script introduces the Turbo JMA (Jurik Moving Average) to your trading charts. It is designed to provide a smoother, more responsive trend-following line compared to standard moving averages by utilizing advanced mathematical filtering.

Here is a breakdown of how the logic works in plain English:

Core Purpose

The primary goal of this script is to solve a common problem in trading: the "lag" vs. "smoothness" trade-off. Most indicators are either very smooth but react too slowly to price changes, or they react quickly but are too "noisy" and jumpy. The Turbo JMA uses complex internal calculations to minimize both of these issues simultaneously.

How it Processes Data

Instead of simply averaging the last few prices (like a Simple Moving Average), this script follows a sophisticated multi-step process:

  • Price Input: It specifically looks at the "Typical Price," which is the average of the High, Low, and Close prices for each candle. This provides a more balanced view of market activity than using just the closing price.
  • Dynamic Weighting: The script uses a "Phase" and "Length" setting to determine how it should prioritize recent data versus older data. It creates a weighted system that allows the line to "bend" more naturally with the market trend.
  • Signal Filtering: It employs an internal loop that calculates price deviations. By measuring how much the current price varies from previous values, it can distinguish between genuine trend shifts and minor market noise (volatility).
  • Smoothing Layers: The logic applies multiple layers of mathematical "folding." Think of this like a series of filters: as the raw price enters the script, it is smoothed, then adjusted for momentum, and finally refined to ensure the resulting line is sleek.

Key Technical Behaviors

  • Trend Adaptation: Because of its unique math, the indicator is designed to stay very close to the price during strong trends while remaining exceptionally flat during sideways (choppy) markets.
  • Reduced Lag: It utilizes a specific calculation style that "anticipates" the curve of the price slightly better than standard moving averages, aiming to provide entry and exit signals faster without sacrificing the cleanliness of the line.
  • Stability: The script includes safeguards to ensure that when the indicator starts up (initialization), it doesn't produce erratic jumps or errors, ensuring a consistent visual experience from the very first candle on your chart.

Summary for the User

In short, this is a high-performance smoothing tool. It takes messy market data and converts it into a clean, "turbo" charged trend line that reacts quickly to new information but ignores the "static" of minor price fluctuations. It is ideal for traders who need to see the clear direction of the market without being distracted by constant, jagged movements.

12 Views
0 Downloads
0 Favorites
JMA 
//+------------------------------------------------------------------+
//|                                                    Turbo_JMA.mq4 |
//|                                             Weld, Jurik Research |
//|                   Modified by bluto to use Typical Price (HLC/3) |
//|                                          http://weld.torguem.net |
//+------------------------------------------------------------------+
#property copyright "Weld"
#property link      "http://weld.torguem.net"

#property indicator_chart_window
#property indicator_buffers 1
#property indicator_color1 Aqua
//---- input parameters
extern int       Length = 14;
extern int       Phase  = 0;
//---- buffers
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(4);
//---- drawing settings
   SetIndexStyle  (0, DRAW_LINE);
   SetIndexDrawBegin(0, 30);
//---- 4 indicator buffers mapping
   SetIndexBuffer (0, JMAValueBuffer);
   SetIndexBuffer (1, fC0Buffer);
   SetIndexBuffer (2, fA8Buffer);
   SetIndexBuffer (3, fC8Buffer); 
//---- initialize one buffer (neccessary)   
   ArrayInitialize (ring2, 0);
   ArrayInitialize (ring1, 0); 
   ArrayInitialize (buffer, 0); 
//---- name for DataWindow and indicator subwindow label
   IndicatorShortName ("Turbo JMA(" + Length + "," + Phase + ")");
   SetIndexLabel (0, "JMAValue");
//---- 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 = ((High[shift]+Low[shift]+Close[shift])/3);
 
      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;
//---- End of main cycle
   } 
   return;
}

//+------------------------------------------------------------------+
int IntPortion (double param) {
   if (param > 0) return (MathFloor (param));
   if (param < 0) return (MathCeil (param));
   return (0.0);
}
//+------------------------------------------------------------------+

Similar scripts

Turbo_JMA

This indicator utilizes a sophisticated non-linear filtering algorithm that employs logarithmic scaling and dynamic memory rings to minimize phase lag while maintaining smooth price trajectory tracking.

JMA!_v1

A sophisticated lagging-reduction indicator that utilizes non-linear dynamic weighting and complex iterative loops to balance smoothness with rapid price response.

JMA [i]

This indicator utilizes a sophisticated recursive algorithm to eliminate price lag while maintaining high sensitivity to trend reversals through dynamic weight adjustment.

JMA_002

This indicator implements a sophisticated non-linear smoothing algorithm that minimizes lag while preserving trend integrity through dynamic phase adjustment and adaptive power calculations.

JMA_001

A sophisticated adaptive moving average that utilizes dynamic power-law calculations and phase shifting to minimize signal lag while maintaining high smoothness.

JMA!

This algorithm utilizes a sophisticated non-linear smoothing technique that dynamically adjusts to price volatility while minimizing lag through a complex adaptive phase and memory-based filtering system.

Turbo_JVEL

Turbo_JVEL1

JMA_StarLight_v1

This indicator implements a complex nonlinear adaptive moving average that utilizes dynamic phase shifts and variable price weighting to minimize lag while preserving trend integrity.

JMASlope_v2

This indicator calculates the directional velocity of the Jurik Moving Average to visualize price momentum through positive and negative slope histograms.

JMASlope_v4

Comments