nonlagdot

Download script
Author: Copyright � 2006, TrendLaboratory
nonlagdot

The NonLagDOT is a sophisticated technical analysis tool designed to track market trends with high precision while minimizing the "lag" typically associated with standard moving averages. In many trading environments, indicators often react to price changes too slowly, causing traders to enter positions after the move has already peaked; this script is specifically engineered to address that issue by using a customized weighting system.

Core Logic and Functionality

The indicator operates based on three primary pillars of logic:

1. Advanced Weighted Calculations Unlike a standard moving average that treats all historical data points with equal importance, this script applies a unique mathematical coefficient to price data. It uses a trigonometric-based weighting system (utilizing cosine functions) to distribute "importance" across a specific look-back period. This allows the indicator to prioritize more relevant information, creating a smoother line that remains responsive to sudden shifts in market momentum.

2. Dynamic Trend Identification The script continuously monitors the rate of change between the current calculated value and the previous one. By analyzing these fluctuations, it determines the "direction" of the market.

  • When the calculated value moves upward significantly beyond a user-defined threshold, it identifies an Upward Trend.
  • When it moves downward significantly, it identifies a Downward Trend.

3. Visual Signaling and Filtering To make the data actionable for the user, the script translates these mathematical calculations into visual cues:

  • Trend Tracking: It assigns specific colors (such as Royal Blue for up-trends and Red for down-trends) to different buffers. This allows a trader to see at a glance whether the current momentum is positive or negative.
  • Noise Reduction (Filtering): The script includes a built-in "Filter" mechanism. This logic prevents the indicator from flickering back and forth during periods of low volatility or "choppy" price action. It ensures that a trend change is only registered if the move is substantial enough to be considered significant.
  • Visual Continuity: Through a "ColorBarBack" logic, the script can visually connect segments of the trend, making it easier for the viewer to see the continuous path of a movement rather than isolated dots.

Summary for Traders

Essentially, this tool takes raw price data and processes it through a specialized weighted formula to produce a smoothed line that highlights the current trend. By filtering out minor market noise and reacting quickly to significant directional shifts, it aims to provide a clearer picture of market direction than standard moving averages can offer.

Indicators Used
Moving average indicator
Miscellaneous
Implements a curve of type %1
16 Views
0 Downloads
0 Favorites
nonlagdot 
//+------------------------------------------------------------------+
//|                                                  NonLagDOT.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 Yellow
#property indicator_width1 2
#property indicator_color2 RoyalBlue
#property indicator_width2 2
#property indicator_color3 Red
#property indicator_width3 2


//---- input parameters
extern int     Price          = 0;
extern int     Length         = 10;
extern int     Displace       = 0;
extern int     Filter         = 0;
extern int     Color          = 1;
extern int     ColorBarBack   = 2;
extern double  Deviation      = 0;         

double Cycle =  4;

//---- indicator buffers
double MABuffer[];
double UpBuffer[];
double DnBuffer[];
double price[];
double trend[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
  int init()
  {
   int ft=0;
   string short_name;
//---- indicator line
   IndicatorBuffers(5);
   SetIndexStyle(0,DRAW_ARROW);
   SetIndexBuffer(0,MABuffer);
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexBuffer(1,UpBuffer);
   SetIndexStyle(2,DRAW_ARROW);
   SetIndexBuffer(2,DnBuffer);
   SetIndexBuffer(3,price);
   SetIndexBuffer(4,trend);
   IndicatorDigits(MarketInfo(Symbol(),MODE_DIGITS));
   SetIndexArrow(0,159);
   SetIndexArrow(1,159);
   SetIndexArrow(2,159);
   SetIndexArrow(3,159);
//---- name for DataWindow and indicator subwindow label
   short_name="NonLagDot("+Length+")";
   IndicatorShortName(short_name);
   SetIndexLabel(0,"NLD");
   SetIndexLabel(1,"Up");
   SetIndexLabel(2,"Dn");
//----
   SetIndexShift(0,Displace);
   SetIndexShift(1,Displace);
   SetIndexShift(2,Displace);
   
   SetIndexDrawBegin(0,Length*Cycle+Length);
   SetIndexDrawBegin(1,Length*Cycle+Length);
   SetIndexDrawBegin(2,Length*Cycle+Length);
//----
   return(0);
  }

//+------------------------------------------------------------------+
//| NonLagMA_v4                                                     |
//+------------------------------------------------------------------+
int start()
{
   int    i,shift, counted_bars=IndicatorCounted(),limit;
   double alfa, beta, t, Sum, Weight, step,g;
   double pi = 3.1415926535;    
   
   double Coeff =  3*pi;
   int Phase = Length-1;
   double Len = Length*Cycle + Phase;  
   
   if ( counted_bars > 0 )  limit=Bars-counted_bars;
   if ( counted_bars < 0 )  return(0);
   if ( counted_bars ==0 )  limit=Bars-Len-1; 
   if ( counted_bars < 1 ) 
   for(i=1;i<Length*Cycle+Length;i++) 
   {
   MABuffer[Bars-i]=0;    
   UpBuffer[Bars-i]=0;  
   DnBuffer[Bars-i]=0;  
   }
   
   for(shift=limit;shift>=0;shift--) 
   {	
   Weight=0; Sum=0; t=0;
       
      for (i=0;i<=Len-1;i++)
	   { 
      g = 1.0/(Coeff*t+1);   
      if (t <= 0.5 ) g = 1;
      beta = MathCos(pi*t);
      alfa = g * beta;
      //if (shift>=1) price[i] = iMA(NULL,0,Per,Displace,Mode,Price,shift+i); 
      //else 
      price[i] = iMA(NULL,0,1,0,MODE_SMA,Price,shift+i); 
      Sum += alfa*price[i];
      Weight += alfa;
      if ( t < 1 ) t += 1.0/(Phase-1); 
      else if ( t < Len-1 )  t += (2*Cycle-1)/(Cycle*Length-1);
      }

	if (Weight > 0) MABuffer[shift] = (1.0+Deviation/100)*Sum/Weight;
   
      if (Filter>0)
      {
      if( MathAbs(MABuffer[shift]-MABuffer[shift+1]) < Filter*Point ) MABuffer[shift]=MABuffer[shift+1];
      }
      
      if (Color>0)
      {
      trend[shift]=trend[shift+1];
      if (MABuffer[shift]-MABuffer[shift+1] > Filter*Point) trend[shift]= 1; 
      if (MABuffer[shift+1]-MABuffer[shift] > Filter*Point) trend[shift]=-1; 
         if (trend[shift]>0)
         {  
         UpBuffer[shift] = MABuffer[shift];
         if (trend[shift+ColorBarBack]<0) UpBuffer[shift+ColorBarBack]=MABuffer[shift+ColorBarBack];
         DnBuffer[shift] = EMPTY_VALUE;
         }
         if (trend[shift]<0) 
         {
         DnBuffer[shift] = MABuffer[shift];
         if (trend[shift+ColorBarBack]>0) DnBuffer[shift+ColorBarBack]=MABuffer[shift+ColorBarBack];
         UpBuffer[shift] = EMPTY_VALUE;
         }
      }
   }
	return(0);	
}

Similar scripts

NonLagMA_v4

This indicator utilizes a cosine-weighted smoothing algorithm to calculate a responsive moving average that minimizes phase shift while isolating trend direction through dual-buffer polarity filtering.

NonLagMA_v4_v1

This indicator utilizes trigonometric weighting and cosine-based coefficients to calculate a responsive moving average that minimizes temporal lag while preserving trend integrity.

NonLagMA_v4_v2

This indicator calculates a sophisticated moving average using trigonometric weights and cyclical coefficients to minimize price lag while smoothing trend detection.

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.

nonlagdot_v2

This indicator calculates a smoothed moving average using cosine-weighted coefficients to identify price momentum and directional shifts while minimizing signal latency.

NonLagMA_v5

This indicator calculates a smoothed moving average by applying a trigonometric cosine weighting system to mitigate temporal lag while identifying directional shifts through price deviation filters.

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.

NonLagMA_v1

This algorithm employs a trigonometric weighted sum and sinusoidal phase distribution to neutralize temporal latency while identifying directional trend bifurcations.

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.

Comments