JMA!

Download script
Author: Weld
JMA!

This script implements a sophisticated technical indicator known as the Jurik Moving Average (JMA). Unlike standard moving averages which often suffer from significant "lag" (delaying the signal) or "overshooting" (becoming too erratic), this logic is engineered to balance both, providing a smoother visual path that stays closer to the actual price action in real-time.

Core Logic Overview

The primary goal of this script is to filter out market "noise"—the small, insignificant fluctuations in price—while remaining highly responsive to significant trend changes. It achieves this through several layers of complex mathematical processing:

1. Dynamic Adaptive Smoothing The script doesn't treat every price movement the same way. It calculates the volatility of the market to determine how much weight to give to new data versus old data. If the market is moving steadily, it smooths the line; if a sharp, significant move occurs, the logic adjusts to "catch up" more quickly than a traditional average would allow.

2. Phase and Length Customization Users can input specific parameters to tune the indicator's personality:

  • Length: Determines the window of data the indicator considers.
  • Phase: Adjusts the "responsiveness." A higher phase can make the indicator react faster to price changes, while a lower phase makes it smoother and slower.

3. Multi-Layered Calculations (The "Big Cycle") To achieve its signature smoothness without the lag of a standard SMA or EMA, the script performs an intensive internal loop. It essentially runs several mini-calculations for every single price point:

  • Difference Tracking: It measures the distance between current prices and previous values to identify the momentum of the move.
  • Logarithmic Processing: It uses logarithmic math to scale these differences, ensuring that extreme price spikes don't "break" the indicator’s shape.
  • Weighted Averages: It passes the data through multiple internal buffers (temporary storage areas) where it is refined repeatedly before the final value is displayed on your chart.

4. The Resulting Visual For the end-user, this complex logic results in a clean, flowing line on the chart. Because of the underlying "Phase" and adaptive smoothing math, the line appears to "hug" the price closely during trends but remains stable and less jittery than most other indicators. This makes it particularly useful for identifying the direction of a trend while ignoring minor market hiccups.

11 Views
0 Downloads
0 Favorites
JMA! 
/*-----------------------------+
|			       |
| Shared by www.Aptrafx.com    |
|			       |
+------------------------------*/

//+------------------------------------------------------------------+
//|                                                          JMA.mq4 |
//|                                             Weld, Jurik Research |
//|                                          http://weld.torguem.net |
//+------------------------------------------------------------------+
#property copyright "Weld"
#property link      "http://weld.torguem.net"
//I'm just intresting in 11 JMA and 8 JMA on 15M charts. No trading 
//activity just alert.

#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 [i]

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

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

A sophisticated adaptive trend-following indicator that utilizes non-linear filtering, logarithmic scaling, and dynamic phase adjustments to minimize lag while preserving signal integrity.

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_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

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