StepMA_v7a_v1

Download script
Author: Copyright � 2006, TrendLaboratory
StepMA_v7a_v1

The StepMA (Step Moving Average) is a sophisticated technical analysis tool designed to help traders identify market trends by smoothing out price fluctuations. Unlike standard moving averages that follow every minor price wiggle, this script focuses on identifying distinct "steps" or structural shifts in price movement.

Core Logic and Functionality

1. Dynamic Volatility Sensing The indicator does not treat all price movements equally. It uses a calculation based on Keltner Channels to assess market volatility. By analyzing the distance between the high and low prices over a specific period, the script determines how much "room" the market is moving in. This allows the tool to adjust its sensitivity automatically—tightening up during stable periods and widening out during high-activity phases.

2. Step Size Determination A key feature of this logic is the calculation of the "Step." Depending on your settings, the script determines a fixed or dynamic distance that the price must move before the trend is considered to have changed. It calculates an average range (ATR) and uses it to ensure that the "steps" are proportional to the current market environment, preventing small noise from triggering false signals.

3. Trend Detection and Filtering The script monitors whether the price has broken above or below specific calculated boundaries.

  • Upward Trend: When the price closes significantly above the current upper boundary, the trend switches to positive.
  • Downward Trend: When the price closes significantly below the current lower boundary, the trend switches to negative.

The logic ensures that once a trend is established, it stays "locked" until the price makes a significant enough move (a "step") in the opposite direction. This prevents the indicator from flickering back and forth during minor price consolidations.

4. Visual Representation Modes The script offers different ways to display this data on your chart:

  • Standard Line: A continuous line that smooths the trend, providing a clear path of market direction.
  • Trend Arrows/Buffers: In more advanced modes, the indicator can separate upward and downward movements into distinct visual elements, making it easier to see exactly where a trend reversal has occurred.

Summary for the User

In plain terms, this tool acts as a "filter" for the market. It ignores the "noise" of minor price fluctuations and only reacts when the price moves with enough strength to form a new step. It tells you not just where the price is going, but helps confirm the underlying structure of the trend by identifying significant shifts in momentum.

Indicators Used
Moving average indicator
Miscellaneous
Implements a curve of type %1
15 Views
0 Downloads
0 Favorites
StepMA_v7a_v1 
/*-----------------------------+
|			       |
| Shared by www.Aptrafx.com    |
|			       |
+------------------------------*/

//+------------------------------------------------------------------+
//|                                                    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 Crimson
#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  = 1000;       
extern int     period      = 10;

//---- 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 get_current_Kv(int shift){
      double u,l;
      find_keltner_channels(shift,u,l);
      double range = (u-l)/Point;
      double c = (Close[shift]-l)/Point;
      if(range!=0)
         return (MathAbs(0.5 - c / range) + Kv);
      return (Kv);
   }
   
   void find_keltner_channels(int shift,double &u,double &l) {
      double sum=0;
      for (int x=shift;x<(shift+period);x++) sum += High[x]-Low[x];
      double avg  = sum/period;
      
      double middle = iMA(NULL, 0, period, 0, MODE_SMA, PRICE_TYPICAL, shift);
      
      u = middle + avg;
      l = middle - avg;
   }
   
   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, get_current_Kv(shift)/*Kv*/, StepSize, shift);
	  Comment (" StepSize= ", Step);
	  StepMA = StepMACalc ( HighLow, Step, shift)+Percentage/100.0*Step*Point;
	  if ( ColorMode == 0) 
	     LineBuffer[shift]=StepMA;
	  else 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;
	        }
	     else 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_v2

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

NonLagDot71

This indicator calculates a zero-lag moving average by applying a cosine-based weighting coefficient to price data, incorporating an optional standard deviation filter to smooth trend transitions.

StepMA_v7_002

This indicator tracks price action by creating a discrete, staircase-like movement that filters market noise through volatility-adjusted step thresholds and trend-switching logic.

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.

RSIFilter_v1_v3

This indicator identifies directional bias by capturing RSI extremes and validating trend persistence through specific overbought/oversold corridor thresholds.

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.

ATRStops_v1.1_001

The algorithm identifies market direction by tracking price breakouts relative to high and low extremes modified by a dynamic Average True Range multiplier.

Comments