StepMA_v7_v2

Download script
Author: Copyright � 2006, TrendLaboratory
StepMA_v7_v2

The StepMA (Step Moving Average) is a specialized technical analysis tool designed to track market trends by identifying significant price movements and "stepping" the average value accordingly, rather than creating a smooth, fluid curve like traditional moving averages. Its logic focuses on recognizing structural shifts in price and maintaining a clean visual representation of the prevailing trend.

Core Logic and Functionality

1. Dynamic Step Calculation The script begins by determining the "Step Size," which represents the minimum distance the indicator moves at any given time. Instead of using a fixed number, it can automatically calculate this size based on market volatility. It looks at the recent range of price fluctuations (High to Low) and identifies the extremes. This allows the tool to adapt: in high-volatility markets, the "steps" become larger, and in quieter markets, the steps become smaller.

2. Trend Detection and Structural Tracking The logic operates by monitoring whether the current price has broken above or below a specific threshold created by previous price action.

  • When the price breaks upward beyond the established boundary, the script identifies an Upward Trend.
  • When it breaks downward, it identifies a Downward Trend.

Once a trend is established, the indicator "locks" into that direction. It will only move in one direction (up or down) until a significant enough price movement occurs to break the current boundary and trigger a reversal. This prevents the indicator from reacting to minor "noise" or small fluctuations in price.

3. Visual Representation Modes The script offers different ways to display this logic on a chart, depending on the user's preference for visual clarity:

  • Single Line: A unified path showing the current stepped average.
  • Separated Trend Lines: The ability to split the visual into distinct "Up" and "Down" components. This allows the user to see exactly where the trend shifts by highlighting the upward movement in one color and the downward movement in another.

Key Characteristics for Traders

  • Volatility Awareness: Because it calculates its steps based on historical price ranges, it is designed to stay relevant whether the market is moving aggressively or slowly.
  • Noise Filtering: By requiring a definitive "break" of a boundary before changing direction, the logic filters out insignificant price wiggles, helping to identify the broader trend more clearly.
  • Price Sensitivity Toggle: The logic includes a specific mode (High/Low) that allows the user to switch between tracking the "Close" price or the "High/Low" extremes, providing options for different trading styles—from conservative to highly sensitive.
Miscellaneous
Implements a curve of type %1
18 Views
0 Downloads
0 Favorites
StepMA_v7_v2 
//+------------------------------------------------------------------+
//|                                                    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;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
   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);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
   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_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_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_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

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

Flat Trend RSI_v1

This indicator identifies directional bias by monitoring RSI extremes and validates trade zones based on specific price momentum thresholds.

ATRStops_v1.1

This algorithm identifies trend direction by calculating rolling volatility envelopes based on Average True Range and locks the trailing support or resistance levels to prevent premature exit signals.

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.

NonLagAMA

This indicator calculates a smoothed moving average by applying a cosine-based weight distribution over a multi-cycle period to minimize phase lag while maintaining price sensitivity.

Comments