Heiken_Ashi_MA_T3_new[Alert+MailAlert]

Download script
Author: Copyright � 2008,Forex-TSD.com
Heiken_Ashi_MA_T3_new[Alert+MailAlert]

This script is a specialized technical analysis tool designed for the MetaTrader 4 platform. It combines two advanced charting concepts—Heiken Ashi candles and T3 Moving Averages—to create a smoothed visual representation of market trends, helping traders identify momentum while filtering out minor market "noise."

Core Logic Overview

The script operates by transforming standard price data into a more readable format through a multi-layered calculation process:

1. Price Smoothing (Moving Average Foundation)

Instead of using the raw opening, closing, high, and low prices of a candle, the script first processes these values through a moving average. It offers two primary options for this:

  • T3 Moving Average: A sophisticated smoothing algorithm designed to reduce "lag" (the delay between a price move and the indicator's reaction) while maintaining a smooth curve.
  • Standard Moving Average: A traditional calculation method used as a simpler alternative.

2. Heiken Ashi Transformation

Once the prices are smoothed by the moving averages, the script applies "Heiken Ashi" logic. Standard candles show the raw price movement, but Heiken Ashi candles calculate an "average" price for each bar. This results in:

  • Trend Clarity: It creates a visual flow where the candle bodies represent the mean price movement rather than individual price spikes.
  • Enhanced Visibility: By calculating the high and low based on these averaged values, it makes it easier to see if the market is consistently moving in one direction or consolidating.

3. Stability Filtering (The "Step" Logic)

To prevent the indicator from flickering or changing too rapidly due to tiny price fluctuations, the script includes a "Step" filter. This ensures that the candles only update their values if the price move exceeds a specific threshold. This provides a much cleaner visual experience for traders who want to avoid being distracted by insignificant market "jitters."

Trading Signals and Alerts

The script is designed to automatically detect trend reversals based on the relationship between the averaged "Open" and "Close" prices:

  • Buy Signals: When the smoothed price structure switches from a downward bias to an upward bias, the script identifies a potential "Buy" opportunity.
  • Sell Signals: Conversely, when the structure shifts from an upward bias to a downward bias, it identifies a "Sell" opportunity.

Notifications

When these trend changes occur, the script provides real-time notifications through three channels:

  1. On-Chart Arrows: Visual markers appear directly on the chart to highlight the entry point.
  2. Pop-up Alerts: Instantaneous visual alerts within the trading platform.
  3. Email Notifications: Optional automated emails sent to the user's registered account, allowing for monitoring even when the trader is away from the computer.
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 screenIt sends emails
12 Views
0 Downloads
0 Favorites
Heiken_Ashi_MA_T3_new[Alert+MailAlert] 
//+------------------------------------------------------------------+
//|                                            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;
extern bool   MailSend      = 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));
               if (MailSend == true) SendMail("HAMa_Signal", "SignalBUY of Symbol: " + Symbol()+", time: " + TimeToStr(TimeCurrent(), TIME_DATE|TIME_MINUTES));
               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));
               if (MailSend == true) SendMail("HAMa_Signal","SignalSELL of Symbol: " + Symbol()+", time: " + TimeToStr(TimeCurrent(), TIME_DATE|TIME_MINUTES));
               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

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]_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

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.

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.

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.

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.

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.

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