StepMA_v7.2_002

Download script
Author: Copyright � 2006, TrendLaboratory
StepMA_v7.2_002

The StepMA script is a specialized technical analysis tool designed to identify market trends by creating a "stepped" moving average. Unlike standard moving averages that flow in smooth, continuous curves, this indicator moves in distinct horizontal plateaus, making it easier for traders to visualize clear periods of price stability and significant trend shifts.

Core Logic and Functionality

1. Dynamic Step Calculation The script begins by determining the "height" of its steps (the vertical distance between price levels). It does this by analyzing market volatility—specifically looking at the range between highs and lows over a set period.

  • If a specific step size is not manually defined by the user, the tool automatically calculates one based on historical volatility. This ensures that the indicator adapts to different market conditions (e.g., taking larger steps during high volatility and smaller steps during quiet periods).

2. Trend Identification & "Breakout" Logic The script determines the direction of the market by monitoring price action relative to these calculated levels:

  • It establishes upper and lower boundaries based on the current price.
  • If the price closes above a certain upper level, the script registers an upward trend.
  • If the price closes below a certain lower level, it registers a downward trend.
  • The indicator "locks" into these trends until a price movement is strong enough to break through the next step, creating a clear visual distinction between market phases.

3. Visual Modes (Coloring and Offsets) The script offers different ways to display this information on a chart:

  • Standard Mode: Displays a single line representing the current stepped average.
  • Trend Coloring: Highlights the moving average in different colors (typically Aqua/Lime for up-trends and Red for down-trends) to provide immediate visual feedback on market direction.
  • Advanced Offsets: For more refined analysis, certain modes allow for "shifts." This adds a small buffer or extra distance to the steps, helping traders avoid "fakeouts" by requiring a slightly larger price move before the indicator confirms a trend change.

4. Automated Alerts The script includes an automated notification system. When the trend flips (for example, moving from an up-trend to a down-trend), the tool can trigger a visual alert on the platform. It is programmed with logic to ensure these alerts only fire once per trend shift, preventing redundant notifications during a single price movement.

Summary for the User

In simple terms, this script acts as a "filter" for market noise. By converting smooth price action into a series of steps, it highlights where the price is genuinely pushing in a new direction versus where it is merely fluctuating within a stable range. It automatically adjusts its sensitivity based on how volatile the market is, providing a more reliable visual guide for trend following.

Miscellaneous
Implements a curve of type %1It issuies visual alerts to the screen
14 Views
0 Downloads
0 Favorites
StepMA_v7.2_002 
//+------------------------------------------------------------------+
//|                                                  StepMA_v7.1.mq4 |
//|                                Copyright © 2006, TrendLaboratory |
//|            http://finance.groups.yahoo.com/group/TrendLaboratory |
//|                                   E-mail: igorad2003@yahoo.co.uk |
//+------------------------------------------------------------------+
//| Modifications:                                                   |
//| - StepMA_v7.2, 2006/06/26, by Ogeima, ph_bresson@yahoo.com       |
//|   - Color Mode 3                                                 |
//|   - UpDownShift to ColorMode2 and ColorMode3                     |
//|   - Fixed LineBuffer[] for every ColorMode, in order to enable   |
//|     applying a MovingAverage(1) on top of the StepMA,            | 
//|     thus enabling the charting of LevelLines on the StepMA       |
//+------------------------------------------------------------------+

#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 Lime
#property indicator_color3 Red

//---- input parameters
extern int     Length      = 10;      // Volty Length
extern double  Kv          = 0.5;     // Sensivity Factor
extern int     StepSize    = 20;       // 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 double  UpDownShift = 0;       // Number of Up/Down Moving, in points. For ColorMode==3 only.
extern bool    HighLow     = false;   // High/Low Mode Switch (more sensitive)
extern int     ColorMode   = 2;       // Color Mode Switch
extern int     BarsNumber  = 0;       

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

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;
	     double Weight = 0;
	     for (int i=Len-1;i>=0;i--)
	     { 
            if(MA_Mode==0) double alfa= 1.0; else alfa= 1.0*(Len-i)/Len; 
            AvgRange+= alfa*(High[k+i]-Low[k+i]);
            Weight += alfa;
        }
	     ATR0 = AvgRange/Weight;
	
	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(0,DRAW_LINE,0,5);
   SetIndexStyle(1,DRAW_LINE,0,5);
   SetIndexStyle(2,DRAW_LINE,0,5);
   
   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.2                                                        |
//+------------------------------------------------------------------+
int start()
{
   int shift, counted_bars=IndicatorCounted();
     
   if ( BarsNumber > 0 ) int Nbars=BarsNumber; else Nbars=Bars;
   if ( counted_bars > 0 )  limit=Bars-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;
            LineBuffer[shift]= UpBuffer[shift];
        if(shift < 3 && DnBuffer[shift] == UpBuffer[shift] && DnBuffer[shift] != EMPTY_VALUE && UpBuffer[shift] != EMPTY_VALUE && alertTag!=Time[0]) {Alert("StepMA_v7 Trend Down on ",Symbol()," Period ",Period());alertTag = Time[0];}
            DnBuffer[shift]=EMPTY_VALUE;
         }
         else
         if ( trend[shift]<0 )
         {
            DnBuffer[shift]=StepMA+Step*Point;
            LineBuffer[shift]= DnBuffer[shift];
        if(shift < 3 && DnBuffer[shift] == UpBuffer[shift] && DnBuffer[shift] != EMPTY_VALUE && UpBuffer[shift] != EMPTY_VALUE && alertTag!=Time[0]) {Alert("StepMA_v7 Trend Up on ",Symbol()," Period ",Period());alertTag = Time[0];}
            UpBuffer[shift]=EMPTY_VALUE;
         }
      }
      else
      if ( ColorMode == 2)
      {
         if (trend[shift]>0) 
         {
            UpBuffer[shift]=StepMA+UpDownShift*Point;
            if ( trend[shift+1] < 0 ) UpBuffer[shift+1] = DnBuffer[shift+1];
            LineBuffer[shift]= UpBuffer[shift];
        if(shift < 3 && DnBuffer[shift] == UpBuffer[shift] && alertTag!=Time[0]) {Alert("StepMA_v7 Trend Down on ",Symbol()," Period ",Period());alertTag = Time[0];}
            DnBuffer[shift]=EMPTY_VALUE;
         }
         if (trend[shift]<0) 
         {
            DnBuffer[shift]=StepMA-UpDownShift*Point;
            if ( trend[shift+1] > 0 ) DnBuffer[shift+1] = UpBuffer[shift+1];
            LineBuffer[shift]= DnBuffer[shift];
        if(shift < 3 && DnBuffer[shift] == UpBuffer[shift] && alertTag!=Time[0]) {Alert("StepMA_v7 Trend Up on ",Symbol()," Period ",Period());alertTag = Time[0];}
            UpBuffer[shift]=EMPTY_VALUE;
         }
      }//end if ( ColorMode == 2)
      else
      if ( ColorMode == 3)
   	{
         if ( trend[shift]>0 )
         {
            UpBuffer[shift]=StepMA+(Step+UpDownShift)*Point;
            LineBuffer[shift]= UpBuffer[shift];
        if(shift < 3 && DnBuffer[shift] == UpBuffer[shift] && DnBuffer[shift] != EMPTY_VALUE && UpBuffer[shift] != EMPTY_VALUE && alertTag!=Time[0]) {Alert("StepMA_v7 Trend Down on ",Symbol()," Period ",Period());alertTag = Time[0];}
            DnBuffer[shift]=EMPTY_VALUE;
         }
         else
         if ( trend[shift]<0 )
         {
            DnBuffer[shift]=StepMA-(Step+UpDownShift)*Point;
            LineBuffer[shift]= DnBuffer[shift];
        if(shift < 3 && DnBuffer[shift] == UpBuffer[shift] && DnBuffer[shift] != EMPTY_VALUE && UpBuffer[shift] != EMPTY_VALUE && alertTag!=Time[0]) {Alert("StepMA_v7 Trend Up on ",Symbol()," Period ",Period());alertTag = Time[0];}
            UpBuffer[shift]=EMPTY_VALUE;
         }
      }//end if ( ColorMode == 3)
      else
      {	
         LineBuffer[shift]=StepMA;
         UpBuffer[shift]=EMPTY_VALUE;
         DnBuffer[shift]=EMPTY_VALUE;
      }
	
   }//end for(shift=limit;shift>=0;shift--) 
	return(0);	
 }

Similar scripts

StepMA_v7.2

StepMA_v7.2_003

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.

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

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.

Comments