AllAverages_v1-Labeled

Download script
Author: Copyright � 2007-08, TrendLaboratory
AllAverages_v1-Labeled

This script is a multi-functional technical analysis tool designed for the MetaTrader 4 platform. Its primary purpose is to calculate and display various types of moving averages on a price chart, allowing traders to visualize trend directions and momentum with high flexibility.

Core Functionality

The tool acts as a comprehensive "all-in-one" moving average engine. Instead of requiring different scripts for different types of averages, this tool allows the user to switch between ten distinct mathematical models simply by changing a setting. These models range from standard industry defaults to more advanced, high-speed formulas.

How the Logic Works

The script follows a multi-layered calculation process to ensure accuracy:

  1. Data Preparation: The script first captures a specific price point (such as the close, open, or high/low of a candle) and prepares it as the baseline data for all subsequent calculations.
  2. Model Selection: Based on user preferences, the script selects one of the following calculation methods:
    • Standard Models: Includes simple averages (SMA), exponential averages (EMA), and smoothed versions (SMMA).
    • Weighted Models: These give more importance to recent price data, including Linear Weighted (LWMA), Sine Weighted (SineWMA), and Triple Moving Average (TriMA).
    • Advanced Models: Includes high-responsiveness options like the Hull Moving Average (HMA), Least Squares Moving Average (LSMA), and "Zero Lag" variations designed to reduce the delay typically found in standard indicators.
  3. Dynamic Calculation: The script performs a "double pass." It calculates a preliminary value for each bar and then applies the specific mathematical weights of the chosen model to produce the final smooth line seen on the chart.
  4. Visual Feedback: Once the calculation is complete, the script draws a continuous orange line on the chart. Additionally, it places a small visual marker (an arrow) at the most recent price point to clearly indicate the current value of the average.

Key Features for the User

  • Customizability: Users can adjust the "Period" (how much historical data is looked at) and the "Shift" (moving the line forward or backward on the chart).
  • Variety: By offering 10 different methods, the tool allows traders to choose the specific balance between "smoothness" (filtering out noise) and "sensitivity" (reacting quickly to price changes) that best fits their trading style.
  • Real-Time Updates: The script automatically updates with every new price tick, ensuring that the moving average line remains current as the market moves.
Indicators Used
Moving average indicator
Miscellaneous
Implements a curve of type %1
15 Views
0 Downloads
0 Favorites
AllAverages_v1-Labeled 
//+------------------------------------------------------------------+
//|                                               AllAverages_v1.mq4 |
//|                             Copyright © 2007-08, TrendLaboratory |
//|            http://finance.groups.yahoo.com/group/TrendLaboratory |
//|                                   E-mail: igorad2003@yahoo.co.uk |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007-08, TrendLaboratory"
#property link      "http://finance.groups.yahoo.com/group/TrendLaboratory"

#property indicator_chart_window
#property indicator_buffers 1
#property indicator_color1  Orange
#property indicator_width1  2  
//---- indicator parameters
extern int Price=0;
extern int MA_Period=14;
extern int MA_Shift=0;
extern int MA_Method=0;
//---- indicator buffers
double MA[];
double aPrice[];
//----
int    draw_begin;
string short_name;

string tLHHL0   ;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
//---- drawing settings
   SetIndexStyle(0,DRAW_LINE);
   SetIndexShift(0,MA_Shift);
   IndicatorDigits(MarketInfo(Symbol(),MODE_DIGITS));
   draw_begin=MA_Period;
//---- indicator short name
   switch(MA_Method)
   {
      case 1 : short_name="EMA(";  break;
      case 2 : short_name="Wilder("; break;
      case 3 : short_name="LWMA("; break;
      case 4 : short_name="SineWMA("; break;
      case 5 : short_name="TriMA("; break;
      case 6 : short_name="LSMA("; break;
      case 7 : short_name="SMMA("; break;
      case 8 : short_name="MMA("; break;
      case 9 : short_name="HMA("; break;
      case 10: short_name="ZeroLagEMA("; break;
      default: MA_Method=0; short_name="SMA(";
   }
   IndicatorShortName(short_name+MA_Period+")");
   SetIndexDrawBegin(0,draw_begin);
   SetIndexLabel(0,short_name+MA_Period+")");
//---- indicator buffers mapping
   IndicatorBuffers(2);
   SetIndexBuffer(0,MA);
   SetIndexBuffer(1,aPrice);
//---- initialization done

tLHHL0 = short_name+MA_Period+")";
   return(0);
}
int deinit()
{
   ObjectDelete(tLHHL0);
   return(0);
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
{
   int limit, i, shift;
   int counted_bars=IndicatorCounted();
     
   if(counted_bars<1)
      for(i=1;i<=draw_begin;i++) MA[Bars-i]=iMA(NULL,0,1,0,0,Price,Bars-i); 
//---- last counted bar will be recounted
   if(counted_bars>0) counted_bars--;
   limit=Bars-counted_bars;

   for(shift=limit; shift>=0; shift--)
   aPrice[shift] = iMA(NULL,0,1,0,0,Price,shift);
   
   for(shift=limit; shift>=0; shift--)
   {
      if(shift == Bars - MA_Period)
      {
         switch(MA_Method)
         {
         case 1 : MA[shift] = SMA(aPrice,MA_Period,shift); break;
         case 2 : MA[shift] = SMA(aPrice,MA_Period,shift); break;
         case 7 : MA[shift] = SMA(aPrice,MA_Period,shift); break;
         case 10: MA[shift] = SMA(aPrice,1,shift); break;
         }
      }
      else
      if(shift < Bars - MA_Period)
      {
         switch(MA_Method)
         {
         case 1 : MA[shift] = EMA(aPrice,MA,MA_Period,shift); break;
         case 2 : MA[shift] = Wilder(aPrice,MA,MA_Period,shift); break;  
         case 3 : MA[shift] = LWMA(aPrice,MA_Period,shift); break;
         case 4 : MA[shift] = SineWMA(aPrice,MA_Period,shift); break;
         case 5 : MA[shift] = TriMA(aPrice,MA_Period,shift); break;
         case 6 : MA[shift] = LSMA(aPrice,MA_Period,shift); break;
         case 7 : MA[shift] = SMMA(aPrice,MA,MA_Period,shift); break;
         case 8 : MA[shift] = MMA(aPrice,MA_Period,shift); break;
         case 9 : MA[shift] = HMA(aPrice,MA_Period,shift); break;
         case 10: MA[shift] = ZeroLagEMA(aPrice,MA,MA_Period,shift); break;
         default: MA[shift] = SMA(aPrice,MA_Period,shift); break;
         }
      }
   }     
//---- done


  if (ObjectFind(tLHHL0) != 0)
      {
          ObjectCreate(tLHHL0,OBJ_ARROW,0,Time[0],MA[0]);
          ObjectSet(tLHHL0,OBJPROP_ARROWCODE,SYMBOL_RIGHTPRICE);
          ObjectSet(tLHHL0,OBJPROP_COLOR,Orange);  
      } 
      else
      {
         ObjectMove(tLHHL0,0,Time[0],MA[0]);
      }
   return(0);
}

double SMA(double array[],int per,int bar)
{
   double Sum = 0;
   for(int i = 0;i < per;i++) Sum += array[i+bar];
  
   return(Sum/per);
}                

double EMA(double array1[],double array2[],int per,int bar)
{
   return(array2[bar+1] + 2.0/(1+per)*(array1[bar] - array2[bar+1]));
}

double Wilder(double array1[],double array2[],int per,int bar)
{
   return(array2[bar+1] + 1.0/per*(array1[bar] - array2[bar+1]));
}

double LWMA(double array[],int per,int bar)
{
   double Sum = 0;
   double Weight = 0;
   
      for(int i = 0;i < per;i++)
      { 
      Weight+= (per - i);
      Sum += array[bar+i]*(per - i);
      }
   if(Weight>0) double lwma = Sum/Weight;
   else lwma = 0; 
   return(lwma);
} 

double SineWMA(double array[],int per,int bar)
{
   double pi = 3.1415926535;
   double Sum = 0;
   double Weight = 0;
   double del = 0.5*pi/per;
     
      for(int i = 0;i < per;i++)
      { 
      Weight+= MathSin(0.5*pi - del*i);
      Sum += array[bar+i]*MathSin(0.5*pi - del*i);
      }
   if(Weight>0) double swma = Sum/Weight;
   else swma = 0; 
   return(swma);
}

double TriMA(double array[],int per,int bar)
{
   double sma[];
   int len = MathCeil((per+1)*0.5);
   ArrayResize(sma,len);
   
   for(int i = 0;i < len;i++) sma[i] = SMA(array,len,bar+i);
   double trima = SMA(sma,len,0);
   
   return(trima);
}
 
double LSMA(double array[],int per,int bar)
{   
   double Sum=0;
   for(int i=per; i>=1; i--) Sum += (i-(per+1)/3.0)*array[per-i+bar];
   double lsma = Sum*6/(per*(per+1));
   return(lsma);
}

double SMMA(double array1[],double array2[],int per,int bar)
{
   double Sum = 0;
   for(int i = 0;i < per;i++) Sum += array1[i+bar+1];
         
   double smma = (Sum - array2[bar+1] + array1[bar])/per;
   return(smma);
}                

double MMA(double array[],int per,int bar)
{
   double Slope = 0;

   for (int i = 1;i <= per;i++)
   {
   double Factor = 1 + (2 * (i - 1));
   Slope += (array[bar + i - 1] * ((per - Factor)/2));
   }
   double sma = SMA(array,per,bar);
   double mma = sma + (6 * Slope) / ((per + 1) * per);
   return(mma);
}

double HMA(double array[],int per,int bar)
{
   double tmp[];
   int len =  MathSqrt(per);
   ArrayResize(tmp,len);
   
   for(int i = 0; i < len;i++) tmp[i] = 2*LWMA(array,per/2,bar+i) - LWMA(array,per,bar+i);  
   double hma = LWMA(tmp,len,0); 
     
   return(hma);
}

double ZeroLagEMA(double array1[],double array2[],int per,int bar)
{
   double alfa = 2.0/(1+per); 
   int lag = 0.5*(per - 1); 
   return(alfa*(2*array1[bar] - array1[bar+lag]) + (1-alfa)*array2[bar+1]);
}

Similar scripts

AllAverages_v1-Lab_tabfix

This indicator computes a comprehensive suite of advanced moving averages including HMA, LSMA, SineWMA, and ZeroLagEMA by recursively processing price data through specialized weighted kernels.

AllAverages_v1-Lab_tab1

A comprehensive technical indicator that calculates and visualizes ten distinct moving average types, including HMA, LSMA, and ZeroLagEMA, to provide multifaceted trend smoothing.

_AllAverages_v1

This indicator calculates and overlays a comprehensive range of advanced moving average types, including smoothed, weighted, and zero-lag variations, by processing secondary price data.

TickAdaptiveRSI_v1

This indicator captures high-frequency momentum by calculating moving averages of sub-millisecond price velocity derived from Adaptive RSI fluctuations.

AllAverages_v1

This indicator calculates a nested smoothing effect by applying various weighted moving average algorithms to an initial moving average of the price data.

xLiquidex_v2_mod1

Comments