ma_AMA_optimized_rosh

Download script
Author: Copyright � 2006, MetaQuotes Software Corp.
ma_AMA_optimized_rosh

This script functions as a sophisticated technical analysis tool designed to smooth out market price fluctuations and identify prevailing trends. Instead of simply following every minor price wiggle, it uses an advanced "Adaptive Moving Average" (AMA) logic to distinguish between actual market movement and insignificant "noise."

Here is the breakdown of how the logic works:

Dynamic Price Adaptation

The script begins by identifying the specific type of price data the user wants to track (such as the opening price, closing price, or a weighted average). It then calculates the difference between consecutive prices to determine the volatility of the market. By measuring these changes, the script can estimate how much of a move is significant versus how much is just minor vibration.

Intelligent Smoothing

The core logic uses a sophisticated mathematical formula to adjust how it reacts to new data:

  • In volatile markets: When the price moves significantly and consistently, the script increases its sensitivity so it can react more quickly to the new trend.
  • In stable markets: When price movement is erratic or small, the script "slows down," providing a smoother line that isn't distracted by minor fluctuations.

This creates an "adaptive" behavior where the indicator moves closer to the price during strong trends and stays further away (providing a smoother average) when the market is moving sideways or is highly disorganized.

Trend Identification and Signaling

To make the data actionable for a trader, the script performs several secondary calculations:

  1. Standard Deviation: It calculates the dispersion of the averages to understand the "normal" range of movement.
  2. Movement Thresholds: The script looks at the change in the average from one moment to the next. If that change exceeds a specific threshold (either a fixed point value or a value based on standard deviation, depending on the settings), it identifies a definitive trend move.
  3. Visual Cues: Based on these identified moves, the script generates specific visual markers:
    • Upward Signals: When a significant upward move is detected, the logic triggers an "up" signal.
    • Downward Signals: When a significant downward move is detected, it triggers a "down" signal.

Summary for the User

In simple terms, this tool acts as a smart filter. It ignores the "static" of the market to show you the actual direction of the price. It tells you when a move is strong enough to be considered a trend, providing visual cues (arrows/markers) to help identify potential entry or exit points based on whether the current momentum is shifting upward or downward.

Indicators Used
Moving average indicator
Miscellaneous
Implements a curve of type %1
7 Views
0 Downloads
0 Favorites
ma_AMA_optimized_rosh
//+------------------------------------------------------------------+
//|                                                AMA optimized.mq4 |
//|                      Copyright © 2006, MetaQuotes Software Corp. |
//|                                Copyright © 2004, by konKop,wellx |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, MetaQuotes Software Corp."
#property link      "optimized by Rosh"

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Gray
#property indicator_color2 Blue
#property indicator_color3 Red
//---- input parameters
extern int       periodAMA=10;
extern double    nfast=2.0;
extern double    nslow=30.0;
extern double    G=2.0;
extern double    dK=2.0;
extern int       PriceType=0; // öåíà, îò êîòîðîé ñòðîèòñÿ 
extern int       AMA_Trend_Type=1;
//PRICE_CLOSE 0 Öåíà çàêðûòèÿ 
//PRICE_OPEN 1 Öåíà îòêðûòèÿ 
//PRICE_HIGH 2 Ìàêñèìàëüíàÿ öåíà 
//PRICE_LOW 3 Ìèíèìàëüíàÿ öåíà 
//PRICE_MEDIAN 4 Ñðåäíÿÿ öåíà, (high+low)/2 
//PRICE_TYPICAL 5 Òèïè÷íàÿ öåíà, (high+low+close)/3 
//PRICE_WEIGHTED 6 Âçâåøåííàÿ öåíà çàêðûòèÿ, (high+low+close+close)/4 

//---- buffers
double AMAbuffer[];
double upAMA[];
double downAMA[];
double AbsBuffer[];

double AMA2Buffer[];
double SumAMABuffer[];
double StdAMA[];

double slowSC,fastSC,dFS;

//+------------------------------------------------------------------+
//| âîçâðàùàåò öåíó                                                  |
//+------------------------------------------------------------------+
double Price(int shift)
  {
//----
   double res;
//----
   switch (PriceType)
      {
      case PRICE_OPEN: res=Open[shift]; break;
      case PRICE_HIGH: res=High[shift]; break;
      case PRICE_LOW: res=Low[shift]; break;
      case PRICE_MEDIAN: res=(High[shift]+Low[shift])/2.0; break;
      case PRICE_TYPICAL: res=(High[shift]+Low[shift]+Close[shift])/3.0; break;
      case PRICE_WEIGHTED: res=(High[shift]+Low[shift]+2*Close[shift])/4.0; break;
      default: res=Close[shift];break;
      }
   return(res);
  }
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   IndicatorBuffers(7);
   SetIndexStyle(0,DRAW_LINE);
   SetIndexBuffer(0,AMAbuffer);
   SetIndexStyle(1,DRAW_ARROW,0,2);
   SetIndexArrow(1,159);
   SetIndexBuffer(1,upAMA);
   SetIndexEmptyValue(1,0.0);
   SetIndexStyle(2,DRAW_ARROW,0,2);
   SetIndexArrow(2,159);
   SetIndexBuffer(2,downAMA);
   SetIndexEmptyValue(2,0.0);
   
   SetIndexBuffer(3,AbsBuffer);
   SetIndexBuffer(4,AMA2Buffer);
   SetIndexBuffer(5,SumAMABuffer);
   SetIndexBuffer(6,StdAMA);
   
   slowSC=(2.0 /(nslow+1));
   fastSC=(2.0 /(nfast+1));
   dFS=fastSC-slowSC;
   
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int    counted_bars=IndicatorCounted();
//----
   int i,limit,limit2;
   double Noise,ER,SSC;
   double SredneeAMA,SumKvadratAMA;
   double val1,val2;
   double dipersion;
   static bool debug=false;
   
   if (debug) return;
   if (counted_bars>0) 
      {
      limit=Bars-counted_bars; 
      limit2=limit;
      }
   if (counted_bars==0)
      {
      ArrayInitialize(AMAbuffer,0);
      ArrayInitialize(upAMA,0);
      ArrayInitialize(downAMA,0);
      ArrayInitialize(AbsBuffer,0);
      ArrayInitialize(AMA2Buffer,0);
      ArrayInitialize(SumAMABuffer,0);
      ArrayInitialize(StdAMA,0);
      
      limit=Bars-1;
      /*
      for (i=limit;i>=0;i--)
         {
         AMAbuffer[i]=0;
         upAMA[i]=0;
         downAMA[i]=0;
         AbsBuffer[i]=0;
         NoiseBuffer[i]=0;
         ERBuffer[i]=0;
         SSCBuffer[i]=0;
         StdAMA[i]=0;
         }
      ArrayInitialize(,)
      */
      limit2=Bars-periodAMA-1;
      }
   limit--;
   limit2--;
   //Print("limit=",limit);
   //Print("Ïîøåë Abs");
   for (i=limit;i>=0;i--)
      {
      AbsBuffer[i]=MathAbs(Price(i)-Price(i+1));
      }   
   //Print("Ïîøåë Noise");
   for (i=limit2;i>=0;i--)
      {
      Noise=iMAOnArray(AbsBuffer,0,periodAMA,0,MODE_SMA,i)*periodAMA;
      if (Noise!=0) ER=MathAbs(Price(i)-Price(i+periodAMA))/Noise; else ER=0;
      SSC=MathPow(ER*dFS+slowSC,G);
      AMAbuffer[i]=Price(i)*SSC+AMAbuffer[i+1]*(1-SSC);
      AMA2Buffer[i]=AMAbuffer[i]*AMAbuffer[i]+AMA2Buffer[i+1];// íàêàïëèâàåì ñóììó êâàäðàòîâ ÀÌû
      SumAMABuffer[i]=SumAMABuffer[i+1]+AMAbuffer[i];
      }   
   //Print("Ïîøåë Std");
   for (i=limit2;i>=0;i--)
      {
      val1=0;
      val2=0;
      SredneeAMA=(SumAMABuffer[i]-SumAMABuffer[i+periodAMA])/periodAMA;
      SumKvadratAMA=AMA2Buffer[i]-AMA2Buffer[i+periodAMA];
      dipersion=SumKvadratAMA/periodAMA-SredneeAMA*SredneeAMA;
      if (dipersion<0)
         {
         StdAMA[i]=0;
         //Print("Îòðèöàòåëüíàÿ äèñïåðñèÿ! çíà÷åíèå:",DoubleToStr(dipersion,8));
         //Print("periodAMA=",periodAMA,"  Bars=",Bars,"    i=",i);
         //Print("Bar;Price;AbsBuffer;AMAbuffer;AMA2Buffer;SumAMABuffer;SredneeAMA");
//         Print(i,";",Price(i),";",AbsBuffer[i],";",AMAbuffer[i],";",AMA2Buffer[i],";",SumAMABuffer[i],";",(SumAMABuffer[i]-SumAMABuffer[i+periodAMA])/periodAMA);

         if (IsTesting()&&false)
            {
            Print("Bar;Price;AbsBuffer;AMAbuffer;AMA2Buffer;SumAMABuffer;SredneeAMA");
            for (int Z=Bars-1;Z>=i;Z--) Print(Z,";",Price(Z),";",AbsBuffer[Z],";",AMAbuffer[Z],";",AMA2Buffer[Z],";",SumAMABuffer[Z],";",(SumAMABuffer[Z]-SumAMABuffer[Z+periodAMA])/periodAMA);
            }
         //debug=true;

         }
      else StdAMA[i]=MathSqrt(dipersion);

      if (AMA_Trend_Type!=0)
         {
         if (MathAbs(AMAbuffer[i]-AMAbuffer[i+1])>dK*Point)
            {
            if (AMAbuffer[i]-AMAbuffer[i+1]>0) val1=AMAbuffer[i];
            else val2=AMAbuffer[i];
            } 
         }
      else
         {
         if (MathAbs(AMAbuffer[i]-AMAbuffer[i+1])>dK*StdAMA[i])
            {
            if (AMAbuffer[i]-AMAbuffer[i+1]>0) val1=AMAbuffer[i];
            else val2=AMAbuffer[i];
            } 
         }         
      upAMA[i]=val1;
      downAMA[i]=val2;
      }
   //Print("Çàêîí÷èëè");

//----
   return(0);
  }
//+------------------------------------------------------------------+

Comments