StepMA_v7_002

Download script
Author: Copyright � 2006, TrendLaboratory
StepMA_v7_002

The StepMA is a technical analysis tool designed to help traders identify market trends by creating a "stepped" moving average. Unlike standard moving averages that produce smooth, curving lines that can sometimes lag behind rapid price movements, the StepMA moves in distinct, horizontal increments. This allows it to act as a clearer visual boundary for price action.

Core Logic and Functionality

The script operates based on three primary logical components: Price Boundary Detection, Dynamic Step Calculation, and Trend Identification.

1. Dynamic Step Calculation

To ensure the indicator adapts to different market conditions (such as high volatility versus low volatility), the script calculates a "Step Size."

  • Automatic Mode: If left at the default setting, the script analyzes historical price ranges to determine the average movement of the asset. It then establishes a step height that is proportional to this volatility.
  • Manual Mode: Users can also input a fixed size, allowing for a constant, predetermined jump in the line's height regardless of market activity.

2. Trend Identification (The "Step" Movement)

The indicator tracks whether the market is currently in an upward or downward state by monitoring specific price triggers:

  • Price Thresholds: The script establishes "ceiling" and "floor" boundaries based on the current step size. It can be configured to look at the actual High/Low prices of a candle (for higher sensitivity) or the Closing prices (for a more stable trend).
  • Directional Shifts: If the market price closes above the upper boundary, the trend is switched to "Up." If it closes below the lower boundary, the trend switches to "Down."

3. Visual Representation and Dynamics

Once a trend is established, the StepMA line follows that direction:

  • In an Uptrend: The indicator seeks to move upward. It "holds" its horizontal position until it reaches a point where it can create a new higher step.
  • In a Downtrend: The indicator seeks to move downward, holding its horizontal level until it can drop to a lower step.
  • Visual Modes: The script offers different ways to display these trends on your chart. It can show a single continuous line, or it can split into separate "Up" and "Down" signals (often accompanied by arrows) to clearly highlight when the trend has flipped from one direction to the other.

Summary for the Trader

In simple terms, this tool filters out the "noise" of small price fluctuations. It only reacts when the market makes a significant enough move to break through a pre-defined threshold. By doing so, it provides a cleaner visual representation of the prevailing trend, helping you identify whether the market is currently pushing higher or lower without the distraction of constant minor weaving.

Miscellaneous
Implements a curve of type %1
11 Views
0 Downloads
0 Favorites
StepMA_v7_002 
//+------------------------------------------------------------------+
//|                                                    StepMA_v7.mq4 |
//|                                Copyright © 2006, TrendLaboratory |
//|            http://finance.groups.yahoo.com/group/TrendLaboratory |
//|                                   E-mail: igorad2003@yahoo.co.uk |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, TrendLaboratory"
#property link      "http://finance.groups.yahoo.com/group/TrendLaboratory"

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Aqua
#property indicator_color2 Blue
#property indicator_color3 Red

//---- input parameters
extern int     Length      = 10;      // Volty Length
extern double  Kv          = 1.0;     // Sensivity Factor
extern int     StepSize    = 0;       // Constant Step Size (if need)
extern int     MA_Mode     = 0;       // Volty MA Mode : 0-SMA, 1-LWMA 
extern int     Advance     = 0;       // Offset
extern double  Percentage  = 0;       // Percentage of Up/Down Moving   
extern bool    HighLow     = false;   // High/Low Mode Switch (more sensitive)
extern int     ColorMode   = 0;       // Color Mode Switch
extern int     BarsNumber  = 0;       

//---- indicator buffers
double LineBuffer[];
double UpBuffer[];
double DnBuffer[];
double smin[];
double smax[];
double trend[];

double StepMA=0, ATR0=0,ATRmax=-100000,ATRmin=1000000;
int limit;

//---- StepSize Calculation

   double StepSizeCalc ( int Len, double Km, int Size, int k)
   {

   double result;
   if( Size==0 ) 
   {
        double AvgRange=0;
	     for (int i=Len-1;i>=0;i--)
	     { 
            if(MA_Mode==0) double alfa= 1.0; else alfa= 1.0+1.0*(Len-i)/Len; 
            AvgRange+= alfa*(High[k+i]-Low[k+i]);
        }
	     ATR0 = AvgRange/Len;
	
	if (ATR0>ATRmax) ATRmax=ATR0;
	if (ATR0<ATRmin) ATRmin=ATR0;
	
	result=MathRound(0.5*Km*(ATRmax+ATRmin)/Point); 
	}
	else
	result=Km*StepSize;
   
   return(result);
   }

//---- StepMA Calculation   
   
   double StepMACalc (bool HL, double Size, int k)
   {
   int counted_bars=IndicatorCounted();
   double result;
   
   if (HL)
	  {
	  smax[k]=Low[k]+2.0*Size*Point;
	  smin[k]=High[k]-2.0*Size*Point;
     } 	
	else  	 
	  {
	  smax[k]=Close[k]+2.0*Size*Point;
	  smin[k]=Close[k]-2.0*Size*Point;
	  }
	  if (counted_bars==0){smax[limit+1]=smax[limit];smin[limit+1]=smin[limit];trend[limit+1]=0;}
	  
	  trend[k]=trend[k+1];   
	  
	  if (Close[k]>smax[k+1]) trend[k]=1;   
	 
	  if (Close[k]<smin[k+1]) trend[k]=-1;  
	 
	  if(trend[k]>0)
	  {
	  if(smin[k]<smin[k+1]) smin[k]=smin[k+1];
	  result=smin[k]+Size*Point;
	  } 
	  else
	  {
	  if(smax[k]>smax[k+1]) smax[k]=smax[k+1];
	  result=smax[k]-Size*Point;
	  }
     //Print (" k=",k," trend=",trend[k], " res=",result," Smax=", smax[k], " Smin=", smin[k]);
	  
     
     return(result); 
     } 
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
  int init()
  {
   string short_name;
//---- indicator line
   IndicatorBuffers(6);
   
   SetIndexStyle(0,DRAW_LINE,STYLE_SOLID,2);
   SetIndexStyle(1,DRAW_LINE);
   SetIndexStyle(2,DRAW_LINE);
   
   SetIndexArrow(1,159);
   SetIndexArrow(2,159);
   
   SetIndexBuffer(0,LineBuffer);
   SetIndexBuffer(1,UpBuffer);
   SetIndexBuffer(2,DnBuffer);
   
   SetIndexShift(0,Advance);
   SetIndexShift(1,Advance);
   SetIndexShift(2,Advance);
   
   SetIndexBuffer(3,smin);
   SetIndexBuffer(4,smax);
   SetIndexBuffer(5,trend);
   
//---- name for DataWindow and indicator subwindow label
   short_name="StepMA("+Length+","+Kv+","+StepSize+")";
   IndicatorShortName(short_name);
   SetIndexLabel(0,short_name);
   SetIndexLabel(1,"UpTrend");
   SetIndexLabel(2,"DownTrend"); 
//----
   SetIndexDrawBegin(0,Length);
   SetIndexDrawBegin(1,Length);
   SetIndexDrawBegin(2,Length);
//----
   return(0);
   }
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
   
//----
   return(0);
  }     
//+------------------------------------------------------------------+
//| StepMA_v7                                                        |
//+------------------------------------------------------------------+
int start()
  {
   int shift, counted_bars=IndicatorCounted();
     
   if ( BarsNumber > 0 ) int Nbars=BarsNumber; else Nbars=Bars;
   if ( counted_bars > 0 )  limit=Nbars-counted_bars;
   if ( counted_bars < 0 )  return(0);
   if ( counted_bars ==0 )  limit=Nbars-Length-1; 
      
	for(shift=limit;shift>=0;shift--) 
   {	
     
	int Step = StepSizeCalc( Length, Kv, StepSize, shift);
				
	Comment (" StepSize= ", Step);
	
	StepMA = StepMACalc ( HighLow, Step, shift)+Percentage/100.0*Step*Point;
	
	if ( ColorMode == 0) LineBuffer[shift]=StepMA;
	
	if ( ColorMode == 1)
	{
	if ( trend[shift]>0 ) {UpBuffer[shift]=StepMA-Step*Point;DnBuffer[shift]=EMPTY_VALUE;}
	else
	if ( trend[shift]<0 ) {DnBuffer[shift]=StepMA+Step*Point;UpBuffer[shift]=EMPTY_VALUE;}
	}
	else
	if ( ColorMode == 2)
	{
	if (trend[shift]>0) 
	  {
	  UpBuffer[shift]=StepMA;
	  if ( trend[shift+1] < 0 ) UpBuffer[shift+1] = DnBuffer[shift+1];
	  DnBuffer[shift]=EMPTY_VALUE;
	  }
	  if (trend[shift]<0) 
	  {
	  DnBuffer[shift]=StepMA;
	  if ( trend[shift+1] > 0 ) DnBuffer[shift+1] = UpBuffer[shift+1];
	  UpBuffer[shift]=EMPTY_VALUE;
	  }
	}
	else
	{	
	UpBuffer[shift]=EMPTY_VALUE; DnBuffer[shift]=EMPTY_VALUE;
	}
	
	}
	return(0);	
 }

Similar scripts

StepMA_v7

This indicator calculates a quantized price trajectory by determining dynamic step sizes based on average range volatility and applying trend-dependent price boundaries.

StepMA_v7EA

This indicator tracks market direction by establishing price boundaries based on weighted average ranges and dynamic step increments to filter out minor noise.

StepMA_v7.1

This indicator calculates a quantized staircase moving average that filters market noise by locking price movements into discrete volatility-adjusted steps.

stepma

This indicator utilizes a volatility-adjusted step mechanism to filter market noise and identify structural trend shifts through discrete price level transitions.

StepMA_v7_v1

This indicator constructs a quantized price trend by calculating discrete step values based on ATR-derived volatility and price breakout detection.

StepMA_v7[1].1

This indicator generates a staircase-style trend line by calculating price movement thresholds based on the relative range of historical volatility.

StepMA_v7a_v1

This indicator calculates a staircase-style moving average by dynamically adjusting step sizes based on Keltner Channel volatility and price position relative to the range.

StepMA_v7_v2

This indicator identifies trend momentum by constructing a discrete price staircase that adjusts its step height based on historical volatility ranges.

StepMA_v7.2_004

A trend-following indicator that utilizes price action breakouts and ATR-derived volatility scaling to generate quantized, stair-step price levels.

NonLagMA_v4_v2

This indicator calculates a sophisticated moving average using trigonometric weights and cyclical coefficients to minimize price lag while smoothing trend detection.

NonLagMA_v4_v1

This indicator utilizes trigonometric weighting and cosine-based coefficients to calculate a responsive moving average that minimizes temporal lag while preserving trend integrity.

Comments