Hist_StepMA_Stoch_KV1_Ex_03

Download script
Author: Copyright � 2005, TrendLaboratory Ltd.
Hist_StepMA_Stoch_KV1_Ex_03

This script is a specialized technical analysis tool designed to identify and visualize market trends by measuring price volatility and calculating "step" movements. Instead of just looking at raw price action, it attempts to quantify the intensity of the market's movement to determine the strength of the current trend.

Core Logic and Methodology

1. Volatility Measurement (WATR) The script begins by analyzing a specific window of recent price bars. It calculates a weighted average of the range (the difference between the high and low prices) for each bar. By weighting recent bars differently, it creates a dynamic sense of how "stretched" or "volatile" the market is at any given moment. This helps the tool distinguish between a quiet market and a highly active one.

2. Dynamic Step Calculation Based on the volatility measured above, the script establishes three different "step sizes." Think of these as different thresholds for price movement:

  • Small Steps: Based on the minimum volatility observed recently.
  • Large Steps: Based on the maximum volatility observed recently.
  • Middle Steps: An average of the two.

These steps act as boundaries. If the market moves significantly enough to cross these boundaries, the script recognizes it as a meaningful shift in direction rather than just random noise.

3. Trend Identification The tool constantly compares the current closing price against these dynamic boundaries. It tracks three different trend levels simultaneously (Minimum, Maximum, and Middle).

  • If the price breaks above a boundary, it registers an upward trend.
  • If the price drops below a boundary, it registers a downward trend.

The script is designed to be "sticky"—it remembers its previous trend state. It only updates the trend direction when the price moves significantly enough to break the established threshold, which helps filter out minor fluctuations that might otherwise trigger false signals.

4. Stochastic Normalization and Visualization Finally, the script converts these complex trend calculations into a simplified visual format (a histogram).

  • It calculates a "Stochastic" value by comparing the relative positions of the Minimum and Middle trend lines against the Maximum trend line.
  • The result is mapped to a scale where values above zero represent upward momentum and values below zero represent downward momentum.
  • The final output shows as a histogram: it highlights the magnitude of the trend in one color while keeping the opposing force at zero, providing a clear visual representation of which way the market "weight" is leaning.

Summary for the User

In simple terms, this script looks at how much the market is moving (volatility) and sets up three different "tripwires." When the price crosses these tripwires, the script identifies the direction of the trend. It then plots these trends as a histogram, making it easier for a trader to see the strength and direction of the current price movement at a glance.

Miscellaneous
Implements a curve of type %1
11 Views
0 Downloads
0 Favorites
Hist_StepMA_Stoch_KV1_Ex_03 
//+------------------------------------------------------------------+
//|                                             StepMA_Stoch_KV1.mq4 |
//|                           Copyright © 2005, TrendLaboratory Ltd. |
//|                                       E-mail: igorad2004@list.ru |
//|                           modified by Kalenzo -> simone@konto.pl |
//|                           modified by raduga  21.04.2006         |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2005, TrendLaboratory Ltd."
#property link      "E-mail: igorad2004@list.ru"

#property indicator_separate_window
#property indicator_buffers 2
#property indicator_color1 Red
#property indicator_color2 Green
#property indicator_level1 0.04
#property indicator_level2 -0.04
//#property indicator_minimum -1
//#property indicator_maximum 1

//---- input parameters
extern int PeriodWATR=10;
extern double Kwatr=1.0000;
extern int HighLow=0;
extern int NumberOfBarsToCalculate = 500;
//---- indicator buffers
double LineMinBuffer[];
double LineMidBuffer[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
  int init()
  {
 Comment("");
//---- indicator line
   SetIndexStyle(0,DRAW_HISTOGRAM,STYLE_SOLID,2);
   SetIndexStyle(1,DRAW_HISTOGRAM,STYLE_SOLID,2);
   SetIndexBuffer(0,LineMinBuffer);
   SetIndexBuffer(1,LineMidBuffer);
   IndicatorDigits(MarketInfo(Symbol(),MODE_DIGITS));
//---- name for DataWindow and indicator subwindow label
   //short_name="StepMA Stoch("+PeriodWATR+","+Kwatr+","+HighLow+")";
   
   SetIndexLabel(0,"StepMA Stoch 1");
   SetIndexLabel(1,"StepMA Stoch 2");
//----
   SetIndexDrawBegin(0,PeriodWATR);
   SetIndexDrawBegin(1,PeriodWATR);
   /**
   *raduga:
   *USELESS !!!! Throws "ArrayInitialization" Exception !!!!
   **/
   //======================================================
   //ArrayInitialize(LineMinBuffer,0);
   //ArrayInitialize(LineMidBuffer,0);
   SetIndexEmptyValue(0,0.0);
   SetIndexEmptyValue(1,0.0);
   //=====================================================
//----
   return(0);
  }

//+------------------------------------------------------------------+
//| StepMA_3D_v1                                                         |
//+------------------------------------------------------------------+
int start()
  {
      string short_name;
      short_name = "Max bars to count: |"+(Bars-1)+"| ";
      IndicatorShortName(short_name);

   int      i,shift,TrendMin,TrendMax,TrendMid;
   double   SminMin0,SmaxMin0,SminMin1,SmaxMin1,SumRange,dK,WATR0,WATRmax,WATRmin,WATRmid;
   double   SminMax0,SmaxMax0,SminMax1,SmaxMax1,SminMid0,SmaxMid0,SminMid1,SmaxMid1;
   double   linemin,linemax,linemid,Stoch1,Stoch2,bsmin,bsmax;
   //raduga : Variable theDelta - has a differense between two bsmin/max lines
   double theDelta;
   
   double prev_y = 0,prev_b = 0;
   	
   for(shift=NumberOfBarsToCalculate-1;shift>=0;shift--)
   {	
	SumRange=0;
	//raduga: initialization because of ZERO-DEVIDE ERROR
	//===============================
	Stoch1 = 0.0;
	Stoch2 = 0.0;
	//===============================
	for (i=PeriodWATR-1;i>=0;i--)
	    { 
       dK = 1+1.0*(PeriodWATR-i)/PeriodWATR;
       //raduga: MathAbs has no sense ragarding High - Low... Probably Close - open !!!!
       //SumRange+= dK*MathAbs(High[i+shift]-Low[i+shift]);
       SumRange+= dK*(High[i+shift]-Low[i+shift]);
       }
	WATR0 = SumRange/PeriodWATR;
	
	WATRmax=MathMax(WATR0,WATRmax);
	if (shift==NumberOfBarsToCalculate-1-PeriodWATR) WATRmin=WATR0;
	WATRmin=MathMin(WATR0,WATRmin);
	
	int StepSizeMin=MathRound(Kwatr*WATRmin/Point);
	int StepSizeMax=MathRound(Kwatr*WATRmax/Point);
	int StepSizeMid=MathRound(Kwatr*0.5*(WATRmax+WATRmin)/Point);
		
	if (HighLow>0)
	  {
	  SmaxMin0=Low[shift]+2*StepSizeMin*Point;
	  SminMin0=High[shift]-2*StepSizeMin*Point;
	  
	  SmaxMax0=Low[shift]+2*StepSizeMax*Point;
	  SminMax0=High[shift]-2*StepSizeMax*Point;
	  
	  SmaxMid0=Low[shift]+2*StepSizeMid*Point;
	  SminMid0=High[shift]-2*StepSizeMid*Point;
	  
	  if(Close[shift]>SmaxMin1) TrendMin=1; 
	  if(Close[shift]<SminMin1) TrendMin=-1;
	  
	  if(Close[shift]>SmaxMax1) TrendMax=1; 
	  if(Close[shift]<SminMax1) TrendMax=-1;
	  
	  if(Close[shift]>SmaxMid1) TrendMid=1; 
	  if(Close[shift]<SminMid1) TrendMid=-1;
	  }
	 
	if (HighLow == 0)
	  {
	  SmaxMin0=Close[shift]+2*StepSizeMin*Point;
	  SminMin0=Close[shift]-2*StepSizeMin*Point;
	  
	  SmaxMax0=Close[shift]+2*StepSizeMax*Point;
	  SminMax0=Close[shift]-2*StepSizeMax*Point;
	  
	  SmaxMid0=Close[shift]+2*StepSizeMid*Point;
	  SminMid0=Close[shift]-2*StepSizeMid*Point;
	  
	  if(Close[shift]>SmaxMin1) TrendMin=1; 
	  if(Close[shift]<SminMin1) TrendMin=-1;
	  
	  if(Close[shift]>SmaxMax1) TrendMax=1; 
	  if(Close[shift]<SminMax1) TrendMax=-1;
	  
	  if(Close[shift]>SmaxMid1) TrendMid=1; 
	  if(Close[shift]<SminMid1) TrendMid=-1;
	  }
	 	
	  if(TrendMin>0 && SminMin0<SminMin1) SminMin0=SminMin1;
	  if(TrendMin<0 && SmaxMin0>SmaxMin1) SmaxMin0=SmaxMin1;
		
	  if(TrendMax>0 && SminMax0<SminMax1) SminMax0=SminMax1;
	  if(TrendMax<0 && SmaxMax0>SmaxMax1) SmaxMax0=SmaxMax1;
	  
	  if(TrendMid>0 && SminMid0<SminMid1) SminMid0=SminMid1;
	  if(TrendMid<0 && SmaxMid0>SmaxMid1) SmaxMid0=SmaxMid1;
	  
	  
	  if (TrendMin>0) linemin=SminMin0+StepSizeMin*Point;
	  if (TrendMin<0) linemin=SmaxMin0-StepSizeMin*Point;
	  
	  if (TrendMax>0) linemax=SminMax0+StepSizeMax*Point;
	  if (TrendMax<0) linemax=SmaxMax0-StepSizeMax*Point;
	  
	  if (TrendMid>0) linemid=SminMid0+StepSizeMid*Point;
	  if (TrendMid<0) linemid=SmaxMid0-StepSizeMid*Point;
	  
	  bsmin=linemax-StepSizeMax*Point;
	  bsmax=linemax+StepSizeMax*Point;
	  //raduga: ZERO-DEVIDE-ERROR
	  //=============================
	  theDelta = bsmax-bsmin;
	  if(theDelta != 0) 
	  {
	     Stoch1=NormalizeDouble((linemin-bsmin)/theDelta,6);
	     Stoch2=NormalizeDouble((linemid-bsmin)/theDelta,6);
	  }
	  //==============================   
	  prev_y = (Stoch1 - Stoch2);
	  if(prev_y<0.0){
	     LineMinBuffer[shift] = prev_y;
	     LineMidBuffer[shift] = 0;
	     }
	  else if(prev_y>0.0){
	     LineMidBuffer[shift] = prev_y;
	     LineMinBuffer[shift] = 0;
	     }
	  
	  //prev_y = Stoch1;
	  //prev_b = Stoch2;
	  
	  
	  SminMin1=SminMin0;
	  SmaxMin1=SmaxMin0;
	  
	  SminMax1=SminMax0;
	  SmaxMax1=SmaxMax0;
	  
	  SminMid1=SminMid0;
	  SmaxMid1=SmaxMid0;
	 }
	return(0);	
 }

Similar scripts

Hist_StepMA_Stoch_KV1_Ex_03-All-bars

This indicator identifies trend momentum by calculating price steps relative to a weighted volatility range, converting the divergence between minimum and median step boundaries into a normalized stochastic histogram.

Hist_StepMA_Stoch_KV1_Ex_03_v2

This indicator calculates a three-tiered volatility boundary based on ATR-style ranges to determine directional trend bias and normalize it into a dual-line stochastic histogram.

Hist_StepMA_Stoch_KV1_Ex_03_001

This indicator calculates dynamic price step boundaries based on weighted ATR volatility to generate a normalized stochastic oscillator that measures trend momentum shifts.

Hist_StepMA_Stoch_KV1_Ex_034

This indicator calculates momentum by measuring the deviation of current price action relative to a volatility-adjusted step range, normalized into an oscillator format.

Hist_StepMA_Stoch_KV1_Ex_031

This indicator calculates volatility-adjusted price steps and maps their relative positions onto a stochastic oscillator to identify trend momentum based on dynamic price ranges.

Hist_StepMA_Stoch_KV1_Ex_02

This indicator utilizes a weighted ATR-based volatility scale to project multi-tiered price steps and normalize their relative positions into a differential stochastic oscillator.

Hist_StepMA_Stoch_KV1_Ex_02_with_Filterlevels

This indicator calculates multi-layered trend steps based on weighted volatility ranges to generate a normalized momentum oscillator.

Hist_StepMA_Stoch_KV1_Ex_02_with Filterlevels(2)

This indicator calculates a dual-layered stochastic oscillator based on Step Moving Average price boundaries derived from dynamic volatility ranges.

Hist_StepMA_Stoch_KV1_Ex_02_v1

This indicator quantifies market volatility using a Weighted Average True Range (WATR) to establish dynamic step-based boundaries, then calculates momentum via the relative positioning of trend-adaptive price levels.

Hist_StepMA_Stoch_KV1_Ex_03_v1

This indicator calculates dynamic price-action boundaries based on weighted volatility ranges to generate a stochastic oscillator that measures the divergence between minimum and median trend steps.

StepMA_Stoch_v1_v1

This indicator calculates dynamic price thresholds based on a weighted range average to generate multi-tiered momentum levels that normalize trend strength into an oscillator format.

Comments