StepMA_v7.2

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

The StepMA (Step Moving Average) is a specialized technical analysis tool designed to identify and visualize market trends by creating a "stepped" visual representation of price action. Unlike traditional moving averages that produce smooth, continuous curves, this script calculates price levels that move in distinct increments, making it easier for traders to identify specific support and resistance zones or trend shifts.

Core Logic and Mechanics

1. Dynamic Step Calculation The script first determines how "large" each step should be. It does this by analyzing the market's volatility—specifically looking at the difference between high and low prices over a set period.

  • If a fixed step size is not manually defined, the tool automatically calculates a dynamic step based on recent price range extremes.
  • This ensures that the "steps" are proportional to the current market environment; they will be larger during high-volatility periods and smaller during quieter markets.

2. Trend Detection (The "Breakout" Logic) To decide whether the price is moving up or down, the script establishes a protective "buffer zone" around the current price.

  • It monitors whether the price closes significantly above or below these calculated boundaries.
  • When a breakout occurs, the script registers a change in trend direction (Up or Down). This creates a logic gate that prevents the moving average from reacting to minor "noise," only updating when a significant price movement is confirmed.

3. Step Generation and Plotting Once a trend is established, the indicator calculates the position of the line:

  • In an Uptrend: The script holds the value at a specific level until the price breaks downward, at which point it "steps" down.
  • In a Downtrend: The script holds the value at a level until the price breaks upward, at which point it "steps" up. The resulting visual is a staircase-like line that follows the prevailing momentum of the market.

Visual and Alert Features

The script offers different Color Modes to customize how these steps appear on your chart:

  • Standard Mode: Displays the basic stepped moving average as a single line.
  • Dynamic Offsets: In advanced modes, the script can slightly shift the price levels (Up/Down Shift) or add extra percentage offsets. This allows traders to create more breathing room between the indicator and the price action.
  • Trend Highlighting: The indicator can differentiate between upward and downward movements using distinct colors (e.g., Aqua for Up, Red for Down), providing a clear visual cue of the current market bias.
  • Automated Alerts: The logic includes an automated notification system. When the trend flips—specifically when the "Up" line and "Down" line cross or overlap—the script can trigger a real-time alert to notify the user of a potential change in market direction.

Summary for the User

Essentially, this tool filters out minor price fluctuations to show you the "macro" staircase of the market. It tells you where the current trend is holding and provides a clear visual signal the moment the price breaks out of its current step into a new direction.

Miscellaneous
Implements a curve of type %1It issuies visual alerts to the screen
12 Views
1 Downloads
0 Favorites
StepMA_v7.2 
//+------------------------------------------------------------------+
//|                                                  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 Blue
#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_002

This indicator generates a quantized price progression by calculating dynamic vertical steps based on historical volatility and high/low extremes to identify structural trend shifts.

StepMA_v7.2_003

This indicator calculates a staircase-style moving average that adjusts its vertical displacement based on real-time price range volatility and trend direction.

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