Heiken Ashi Ma T3 new

Download script
Author: Copyright � 2008,Forex-TSD.com
Heiken Ashi Ma T3 new

The Heiken Ashi Ma T3 script is a specialized technical analysis tool designed to smooth out market price fluctuations and provide clearer visual signals for trend direction. It combines two sophisticated mathematical concepts—Heiken Ashi candles and the T3 Moving Average—to filter out "market noise" that often makes it difficult for traders to identify the underlying trend.

Core Logic and Functionality

1. Dual Layer Smoothing Instead of calculating data based on raw, volatile price points (like the standard High, Low, Open, and Close prices), this script first passes those values through a T3 Moving Average. The T3 is a proprietary moving average known for being faster and smoother than traditional averages, reducing the "lag" that usually occurs when an indicator tries to keep up with rapid price movements.

2. Heiken Ashi Integration The script then takes these smoothed T3 values and converts them into Heiken Ashi format. Heiken Ashi is a Japanese candlestick style where each candle's value is averaged from the previous period's data. By applying this to the T3 averages, the script creates a visual representation of momentum that is much easier for the human eye to read than standard price bars.

3. Trend Identification and Visual Signals The primary purpose of the logic is to detect shifts in market direction:

  • Bullish Trend: When the smoothed data indicates an upward shift, the script identifies a "Turned Up" state.
  • Bearish Trend: When the data indicates a downward shift, it identifies a "Turned Down" state.
  • Visual Markers: The tool places specific arrows on the chart to notify the user of these shifts in real-time.

4. Noise Filtering (The Step Mechanism) A unique feature of this script is its ability to ignore minor price fluctuations. It includes a "Step" logic that prevents the indicator from reacting to tiny, insignificant movements. Unless the price movement exceeds a specific threshold defined by the user, the indicator will maintain its previous state. This helps traders stay in a trend longer and avoids getting "whipsawed" by small, erratic price jumps.

5. Automated Alerts To ensure the trader doesn't have to watch the screen constantly, the script includes an automated alert system. When the logic detects a confirmed change in momentum (a transition from bearish to bullish or vice versa), it triggers a pop-up notification with the specific symbol and time of the trade signal.

Summary for the User

In short, this tool acts as a "filter." It takes messy market data, cleans it using high-performance averages (T3), reshapes it into easy-to-read candles (Heiken Ashi), and then monitors that data to provide clear buy/sell alerts while ignoring small price jitters that could lead to false signals.

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
13 Views
0 Downloads
0 Favorites
Heiken Ashi Ma T3 new 
//+------------------------------------------------------------------+
//|                                            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      = 5;
extern int    MaMetod       = 2;
extern int    Step          = 10;
extern bool   BetterFormula = true;
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[Alert]_001

This indicator synthesizes smoothed T3 moving averages with Heiken Ashi price modeling to identify trend reversals through filtered directional 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