JMA [i]

Author: Weld
JMA [i]

This technical script implements the Jurik Moving Average (JMA), a sophisticated financial indicator designed to provide a smooth representation of price trends while significantly reducing the "lag" typically associated with standard moving averages.

To help you understand how it functions without diving into the code, here is a breakdown of its internal logic:

Core Objectives

The primary goal of this logic is to solve two conflicting problems in trading analysis:

  1. Smoothness: Removing "noise" (erratic price spikes) so the trend is easy to read.
  2. Responsiveness: Ensuring the indicator reacts quickly enough to new price movements so that traders aren't entering positions too late.

How the Logic Works

1. Dynamic Input Processing The script begins by calculating several internal variables based on your chosen inputs (Length and Phase). It uses logarithmic calculations and square roots to determine how "aggressively" the indicator should react. This ensures that the smoothing effect scales correctly regardless of the timeframe or asset being traded.

2. Dual-Layer Processing (The "Big Cycle") Unlike a simple moving average that just adds up recent prices, this script performs a complex two-stage calculation:

  • Adaptive Smoothing: The logic identifies whether the current price movement is significant or just minor noise. It uses a specialized memory buffer to track historical price volatility. If the price moves significantly, the indicator adapts to follow that move more quickly; if the price is oscillating mildly, it remains smoother.
  • Non-Linear Weighting: It calculates "distances" between prices and previous values. It then applies a power-based formula to decide how much weight to give to the newest data point versus the historical average.

3. The Filtering Chain The script processes the price through three distinct mathematical layers (represented by internal buffers):

  • Level 1: Captures the raw price movement and applies an initial smoothing pass.
  • Level 2: Refines that movement to filter out minor flickers or "jitter."
  • Level 3: Finalizes the calculation into the smooth line you see on the chart, applying a final phase adjustment (controlled by your "Phase" input).

Summary for the User

In plain English, this script doesn't just look at the last few candles and average them. It analyzes the velocity and volatility of the price. It behaves like a "smart" filter: it tries to stay as close to the price as possible during strong trends (reducing lag) but stays very smooth during choppy markets (reducing false signals).

By using these advanced mathematical cycles, it attempts to provide a "cleaner" trend line than standard tools while remaining more responsive to sudden market shifts.

15 Views
0 Downloads
0 Favorites
JMA [i] 
/*-----------------------------+
|			       |
| Shared by www.Aptrafx.com    |
|			       |
+------------------------------*/

//+------------------------------------------------------------------+
//|                                                          JMA.mq4 |
//|                                             Weld, Jurik Research |
//|                                          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 ("JMAValue(" + 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 = 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;
//---- 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

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.

JMA!_v1

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

Turbo_JMA

JMA

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.

Turbo_JVEL

Turbo_JVEL1

JMA_StarLight_v1

JMASlope_v2

JMASlope_v4

Comments