Heiken_Ashi MA T3 new[Alert]_001

Download script
Author: Copyright � 2008,Forex-TSD.com
Heiken_Ashi MA T3 new[Alert]_001

This technical indicator is designed to provide a smoothed, visual representation of market price trends by combining two distinct types of charting logic: Heiken Ashi and T3 Moving Averages.

Core Concept

The tool aims to filter out "market noise"—the small, erratic price fluctuations that can often mislead traders—and reveal the underlying direction of the trend. It achieves this by recalculating standard price data into a more fluid, readable format.

How the Logic Works

1. Advanced Smoothing (T3 Moving Average) Instead of using a standard moving average, which can sometimes be slow to react or too jittery, this script utilizes the T3 Moving Average. This is a sophisticated calculation that applies multiple layers of "smoothing." By doing this, the indicator identifies price trends with significantly less lag than traditional methods, providing a cleaner view of where the market is headed.

2. Heiken Ashi Transformation The script takes the smoothed data from the T3 moving average and converts it into Heiken Ashi values. In standard charting, every candle represents the raw high, low, open, and close of that specific period. Heikin Ashi charts, however, use an averaging technique to create "synthetic" candles. This makes it much easier to see if the market is in a bullish (upward) or bearish (downward) phase by creating continuous color flows.

3. Trend Filtering and Stability To ensure the visual output remains stable and doesn't flicker or jump unexpectedly, the script includes a "Step" logic. If the price movement is smaller than a specific threshold (the user-defined Step), the indicator holds its previous value. This prevents tiny, insignificant price ticks from triggering false visual changes.

4. Automated Signal Generation The script acts as an automated scout by monitoring the relationship between the opening and closing values of these smoothed candles:

  • Buy Signals: When the trend shifts from a bearish state to a bullish state, the script can place an "Up Arrow" on the chart and trigger a real-time alert.
  • Sell Signals: When the trend shifts from a bullish state to a bearish state, it places a "Down Arrow" and triggers a corresponding alert.

Summary for the User

Think of this tool as a "filter." It takes the messy, jagged movements of the raw market, smooths them out using a high-performance moving average (T3), and then paints them in a way that highlights the momentum (Heiken Ashi). The result is a cleaner chart where the primary trend is easy to see, accompanied by automated alerts when the market's direction significantly flips.

Price Data Components
Series array that contains open time of each bar
Indicators Used
Moving average indicator
Miscellaneous
Implements a curve of type %1It issuies visual alerts to the screen
12 Views
0 Downloads
0 Favorites
Heiken_Ashi MA T3 new[Alert]_001 
//+------------------------------------------------------------------+
//|                                            Heiken Ashi Ma T3.mq4 |
//+------------------------------------------------------------------+
//|                                                      mod by Raff |
//|                                               2009 mod by mladen |
//|  tools copied and pasted alerts from another HA indy so blame me |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2008,Forex-TSD.com"
#property link      "http://www.forex-tsd.com/"

#property indicator_chart_window
#property indicator_buffers 6
#property indicator_color1 Red
#property indicator_color2 RoyalBlue
#property indicator_color3 Red
#property indicator_color4 RoyalBlue
#property indicator_color5 Aqua
#property indicator_color6 Magenta
#property indicator_width1 1
#property indicator_width2 1
#property indicator_width3 2
#property indicator_width4 2
#property indicator_width5 1
#property indicator_width6 1

//
//
//
//
//

extern int    MaPeriod      = 10;
extern int    MaMetod       =  2;
extern int    Step          = 10;
extern bool   BetterFormula = false;
extern bool   T3Average     = true;
extern double T3Hot         = 0.618;
extern bool   T3Original    = false;
extern bool   Alerts        = true;

//
//
//
//
//

double ExtMapBuffer1[];
double ExtMapBuffer2[];
double ExtMapBuffer3[];
double ExtMapBuffer4[];
double UpArrow[];
double DnArrow[];
//
//
//
//
//

double emas[][24];
double alpha;
double c1;
double c2;
double c3;
double c4;




static bool TurnedUp   = false;
static bool TurnedDown = false;
datetime    timeprev   = 0;

//+------------------------------------------------------------------+
//|                                                                  |
//|------------------------------------------------------------------|
//
//
//
//
//

int init()
{
   SetIndexBuffer(0, ExtMapBuffer1); SetIndexStyle(0,DRAW_HISTOGRAM);
   SetIndexBuffer(1, ExtMapBuffer2); SetIndexStyle(1,DRAW_HISTOGRAM);
   SetIndexBuffer(2, ExtMapBuffer3); SetIndexStyle(2,DRAW_HISTOGRAM);
   SetIndexBuffer(3, ExtMapBuffer4); SetIndexStyle(3,DRAW_HISTOGRAM);
   
   SetIndexBuffer(4, UpArrow); SetIndexStyle(4,DRAW_ARROW); SetIndexArrow(4,233);
   SetIndexBuffer(5, DnArrow); SetIndexStyle(5,DRAW_ARROW); SetIndexArrow(5,234);


   //
   //
   //
   //
   //
   
      double a  = T3Hot;
             c1 = -a*a*a;
             c2 =  3*(a*a+a*a*a);
             c3 = -3*(2*a*a+a+a*a*a);
             c4 = 1+3*a+a*a*a+3*a*a;

      MaPeriod = MathMax(1,MaPeriod);
      if (T3Original)
           alpha = 2.0/(1.0 + MaPeriod);
      else alpha = 2.0/(2.0 + (MaPeriod-1.0)/2.0);

   return(0);
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
//
//
//
//
//

int start()
{
   double maOpen, maClose, maLow, maHigh;
   double haOpen, haClose, haLow, haHigh;
   int    counted_bars=IndicatorCounted();
   int    pointModifier;
   int    i,limit;

   //
   //
   //
   //
   //
   if(timeprev<iTime(NULL,0,0)) {TurnedDown=false; TurnedUp=false;timeprev=iTime(NULL,0,0);}
   if(counted_bars<0) return(-1);
   if(counted_bars>0) counted_bars--;
         limit = Bars-counted_bars;
         if (ArrayRange(emas,0) != Bars) ArrayResize(emas,Bars);
         if (Digits==3 || Digits==5)
               pointModifier = 10;
         else  pointModifier = 1;               
          
   //
   //
   //
   //
   //
   
   for(int pos=limit; pos >= 0; pos--)
   {
      if (T3Average)
         {
            maOpen  = iT3(Open[pos] ,pos, 0);
            maClose = iT3(Close[pos],pos, 6);
            maLow   = iT3(Low[pos]  ,pos,12);
            maHigh  = iT3(High[pos] ,pos,18);
         }
      else
         {
            maOpen  = iMA(NULL,0,MaPeriod,0,MaMetod,PRICE_OPEN ,pos);
            maClose = iMA(NULL,0,MaPeriod,0,MaMetod,PRICE_CLOSE,pos);
            maLow   = iMA(NULL,0,MaPeriod,0,MaMetod,PRICE_LOW  ,pos);
            maHigh  = iMA(NULL,0,MaPeriod,0,MaMetod,PRICE_HIGH ,pos);
         }
   
      //
      //
      //
      //
      //
        
         if (BetterFormula) {
               if (maHigh!=maLow)
                     haClose = (maOpen+maClose)/2+(((maClose-maOpen)/(maHigh-maLow))*MathAbs((maClose-maOpen)/2));
               else  haClose = (maOpen+maClose)/2; }
         else        haClose = (maOpen+maHigh+maLow+maClose)/4;
                     haOpen   = (ExtMapBuffer3[pos+1]+ExtMapBuffer4[pos+1])/2;
                     haHigh   = MathMax(maHigh, MathMax(haOpen,haClose));
                     haLow    = MathMin(maLow,  MathMin(haOpen,haClose));

         if (haOpen<haClose) { ExtMapBuffer1[pos]=haLow;  ExtMapBuffer2[pos]=haHigh; } 
         else                { ExtMapBuffer1[pos]=haHigh; ExtMapBuffer2[pos]=haLow;  } 
                               ExtMapBuffer3[pos]=haOpen;
                               ExtMapBuffer4[pos]=haClose;
      
      //
      //
      //
      //
      //

      if (Step>0)
      {
         if( MathAbs(ExtMapBuffer1[pos]-ExtMapBuffer1[pos+1]) < Step*pointModifier*Point ) ExtMapBuffer1[pos]=ExtMapBuffer1[pos+1];
         if( MathAbs(ExtMapBuffer2[pos]-ExtMapBuffer2[pos+1]) < Step*pointModifier*Point ) ExtMapBuffer2[pos]=ExtMapBuffer2[pos+1];
         if( MathAbs(ExtMapBuffer3[pos]-ExtMapBuffer3[pos+1]) < Step*pointModifier*Point ) ExtMapBuffer3[pos]=ExtMapBuffer3[pos+1];
         if( MathAbs(ExtMapBuffer4[pos]-ExtMapBuffer4[pos+1]) < Step*pointModifier*Point ) ExtMapBuffer4[pos]=ExtMapBuffer4[pos+1];
         if (Alerts==true)
        {
         UpArrow[pos]=EMPTY_VALUE; DnArrow[pos]=EMPTY_VALUE;
         if (ExtMapBuffer3[pos]<ExtMapBuffer4[pos] && ExtMapBuffer4[pos+1]<ExtMapBuffer3[pos+1])
           {
            UpArrow[pos]=ExtMapBuffer4[pos+1]-(Ask-Bid);
            if (UpArrow[0]!=EMPTY_VALUE && TurnedUp==false)
              {
               Alert("HAMa  BUY:  ",Symbol()," - ",Period(),"  at  ", Close[0],"  -  ", TimeToStr(CurTime(),TIME_SECONDS));
               TurnedDown=false;
               TurnedUp=true;
              }
           }
         if (ExtMapBuffer3[pos]>ExtMapBuffer4[pos] && ExtMapBuffer4[pos+1]>ExtMapBuffer3[pos+1])
           {
            DnArrow[pos]=ExtMapBuffer4[pos+1]+(Ask-Bid);
            if (DnArrow[0]!=EMPTY_VALUE && TurnedDown==false)
              {
               Alert("HAMa SELL:  ",Symbol()," - ",Period(),"  at  ", Close[0],"  -  ", TimeToStr(CurTime(),TIME_SECONDS));
               TurnedUp=false;
               TurnedDown=true;
              }
           }
         }
       }
      }
   return(0);
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
//
//
//
//
//

double iT3(double price,int shift,int buffer)
{
   int i = Bars-shift-1;
   if (i < 1)
      {
         emas[i][0+buffer] = price;
         emas[i][1+buffer] = price;
         emas[i][2+buffer] = price;
         emas[i][3+buffer] = price;
         emas[i][4+buffer] = price;
         emas[i][5+buffer] = price;
      }
   else
      {
         emas[i][0+buffer] = emas[i-1][0+buffer]+alpha*(price            -emas[i-1][0+buffer]);
         emas[i][1+buffer] = emas[i-1][1+buffer]+alpha*(emas[i][0+buffer]-emas[i-1][1+buffer]);
         emas[i][2+buffer] = emas[i-1][2+buffer]+alpha*(emas[i][1+buffer]-emas[i-1][2+buffer]);
         emas[i][3+buffer] = emas[i-1][3+buffer]+alpha*(emas[i][2+buffer]-emas[i-1][3+buffer]);
         emas[i][4+buffer] = emas[i-1][4+buffer]+alpha*(emas[i][3+buffer]-emas[i-1][4+buffer]);
         emas[i][5+buffer] = emas[i-1][5+buffer]+alpha*(emas[i][4+buffer]-emas[i-1][5+buffer]);
      }
   return(c1*emas[i][5+buffer] + c2*emas[i][4+buffer] + c3*emas[i][3+buffer] + c4*emas[i][2+buffer]);
}

Similar scripts

Heiken Ashi Ma T3 new

This indicator synthesizes Heiken Ashi price action aesthetics with T3 moving average smoothing to identify trend reversals through momentum shifts.

Heiken Ashi MA T3 new_lines[Alert].

This indicator synthesizes Heiken Ashi smoothing techniques with the T3 Moving Average to filter market noise and identify trend reversals through price action convergence.

Heiken Ashi MA T3 new_003

This indicator synthesizes Heiken Ashi price action filtering with a T3 moving average to produce smoothed momentum signals and reduced market noise.

NonLagHAMA T3 new Alert

This indicator synthesizes T3 moving averages with Heikin Ashi price smoothing to identify trend reversals via directional histogram shifts and volatility-adjusted signals.

Heiken_Ashi_MA_T3_new[Alert+MailAlert]

This indicator synthesizes Heiken Ashi smoothing techniques with the T3 moving average to filter price noise and generate directional trend reversals via crossover signals.

RSI_channel_sig

This indicator identifies trend reversals and momentum shifts by applying a T3 moving average filter to Relative Strength Index values within a dynamic high-low price channel.

CCI_T3

This indicator applies a multi-stage weighted triple exponential moving average filter to the Commodity Channel Index to eliminate noise and highlight underlying price momentum.

T3 crosses

This indicator identifies momentum shifts by detecting precise crossover points between two smoothed T3 moving averages and plotting visual markers at ATR-adjusted price levels.

RSI_channel_sig_2

This indicator identifies momentum reversals by applying a T3 smoothing filter to the Relative Strength Index and detecting breaches of dynamically calculated high-low price channels.

tcf smoothed - T3

This indicator quantifies momentum by segregating directional rate of change into cumulative additive components, then applying a triple exponential smoothing algorithm to identify persistent trend strength.

RSI_channel_

This indicator identifies trend extremes by applying a T3 smoothing filter to the Relative Strength Index and overlaying a dynamic volatility channel with integrated ZigZag structure identification.

Comments