T3 Taotra

Download script
T3 Taotra

The T3 indicator is a sophisticated technical analysis tool designed to track price movements by smoothing out "market noise." Unlike standard moving averages that can sometimes be sluggish or lag behind current prices, the T3 logic utilizes a complex mathematical approach to provide a more responsive and fluid representation of trend direction.

Core Logic and Functionality

The script operates on the principle of Triple Smoothing. Instead of calculating a single average, it passes price data through multiple layers of filters. This creates a cascading effect where each layer refines the previous one, effectively stripping away minor price fluctuations while maintaining the integrity of the primary trend.

Key components of this logic include:

  • Multi-Layered Filtering: The script processes price data through six distinct internal buffers. Each buffer takes the result of the previous calculation and applies a weighted adjustment. This "nesting" allows the indicator to remain smooth even when there is high volatility in the underlying asset.
  • Dynamic Weighting: The tool uses a variable (represented as 'b') to control the sensitivity of the curves. This constant determines how aggressively the smoothing is applied; by adjusting this value, the user can choose between a very tight fit to the price action or a much broader, more stable trend line.
  • Weight Distribution: To ensure the indicator reacts accurately to new information, the script calculates specific weights (w1 and w2) for each calculation step. These weights are derived from the periods defined by the user, ensuring that the influence of past data is balanced correctly against current price movements.
  • Visual Representation: The final output is rendered as six separate lines on a separate window. Each line corresponds to a different period setting (e.g., 3, 5, 21, and 34). By viewing these multiple lines simultaneously, traders can observe the "convergence" or "divergence" of trends—identifying where different timeframes agree on market direction.

Summary for the User

In essence, this script takes the current market price and runs it through a specialized mathematical "sieve" six times over. The result is a set of highly polished trend lines that help traders identify the prevailing momentum with less delay than traditional indicators, making it easier to spot smooth transitions in price action.

Miscellaneous
Implements a curve of type %1
12 Views
0 Downloads
0 Favorites
T3 Taotra 
//+------------------------------------------------------------------+
//| T3.mq4 |
//| 
//| |
//+------------------------------------------------------------------+

#property indicator_separate_window
#property indicator_buffers 6
#property indicator_color1 Yellow
#property indicator_color2 Red
#property indicator_color3 Magenta
#property indicator_color4 Aqua
#property indicator_color5 White
#property indicator_color6 Blue

extern int MA_Period_1 = 3;
extern int MA_Period_2 = 5;
extern int MA_Period_3 = 0; //8
extern int MA_Period_4 = 0; //12
extern int MA_Period_5 = 21;
extern int MA_Period_6 = 34;

extern double b = 0.7;

double MapBuffer1[];
double MapBuffer2[];
double MapBuffer3[];
double MapBuffer4[];
double MapBuffer5[];
double MapBuffer6[];

double e1[][7],e2[][7],e3[][7],e4[][7],e5[][7],e6[][7];
double c1[7],c2[7],c3[7],c4[7];
double n[7],w1[7],w2[7],b2[7],b3[7];

//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int init()
{
//---- indicators setting
SetIndexStyle(0,DRAW_LINE,STYLE_SOLID,1,Yellow);
SetIndexStyle(1,DRAW_LINE,STYLE_SOLID,1,Red);
SetIndexStyle(2,DRAW_LINE,STYLE_SOLID,1,Magenta);
SetIndexStyle(3,DRAW_LINE,STYLE_SOLID,1,Aqua);
SetIndexStyle(4,DRAW_LINE,STYLE_SOLID,2,White);
SetIndexStyle(5,DRAW_LINE,STYLE_SOLID,2,Blue);
IndicatorDigits(MarketInfo(Symbol(),MODE_DIGITS));
IndicatorShortName("T3");
SetIndexDrawBegin(0,100);
SetIndexDrawBegin(1,100);
SetIndexDrawBegin(2,100);
SetIndexDrawBegin(3,100);
SetIndexDrawBegin(4,100);
SetIndexDrawBegin(5,100);
SetIndexBuffer(0,MapBuffer1);
SetIndexBuffer(1,MapBuffer2);
SetIndexBuffer(2,MapBuffer3);
SetIndexBuffer(3,MapBuffer4);
SetIndexBuffer(4,MapBuffer5);
SetIndexBuffer(5,MapBuffer6);
//---- variable reset
n[1]=MA_Period_1;
n[2]=MA_Period_2;
n[3]=MA_Period_3;
n[4]=MA_Period_4;
n[5]=MA_Period_5;
n[6]=MA_Period_6;

for(int l=1; l<7; l++)
{

//e2[l]=0; e3[l]=0; e4[l]=0; e5[l]=0; e6[l]=0;
c1[l]=0; c2[l]=0; c3[l]=0; c4[l]=0; 
w1[l]=0; w2[l]=0; 
b2[l]=0; b3[l]=0;

b2[l]=b*b;
b3[l]=b2[l]*b;
c1[l]=-b3[l];
c2[l]=(3*(b2[l]+b3[l]));
c3[l]=-3*(2*b2[l]+b+b3[l]);
c4[l]=(1+3*b+b3[l]+3*b2[l]);

if (n[l]<1) n[l]=1;
n[l] = 1 + 0.5*(n[l]-1);
w1[l] = 2 / (n[l] + 1);
w2[l] = 1 - w1[l];
}



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

//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int start()
{
int limit,MB[],ii,i;
int counted_bars=IndicatorCounted();
if (counted_bars<0) return (-1);
if (counted_bars>0) counted_bars--;
limit=(Bars-counted_bars)-1;
//---- indicator calculation

ArrayResize(e1, Bars+1);
ArrayResize(e2, Bars+1);
ArrayResize(e3, Bars+1);
ArrayResize(e4, Bars+1);
ArrayResize(e5, Bars+1);
ArrayResize(e6, Bars+1);

for(i=limit; i>=0; i--)
{

for(ii=1; ii<7; ii++)
{
e1[Bars-i][ii] = w1[ii]*Close[i] + w2[ii]*e1[(Bars-i)-1][ii];
e2[Bars-i][ii] = w1[ii]*e1[Bars-i][ii] + w2[ii]*e2[(Bars-i)-1][ii];
e3[Bars-i][ii] = w1[ii]*e2[Bars-i][ii] + w2[ii]*e3[(Bars-i)-1][ii];
e4[Bars-i][ii] = w1[ii]*e3[Bars-i][ii] + w2[ii]*e4[(Bars-i)-1][ii];
e5[Bars-i][ii] = w1[ii]*e4[Bars-i][ii] + w2[ii]*e5[(Bars-i)-1][ii];
e6[Bars-i][ii] = w1[ii]*e5[Bars-i][ii] + w2[ii]*e6[(Bars-i)-1][ii];

if (ii==1) MapBuffer1[i]=c1[ii]*e6[Bars-i][ii] + c2[ii]*e5[Bars-i][ii] + c3[ii]*e4[Bars-i][ii] + c4[ii]*e3[Bars-i][ii];
if (ii==2) MapBuffer2[i]=c1[ii]*e6[Bars-i][ii] + c2[ii]*e5[Bars-i][ii] + c3[ii]*e4[Bars-i][ii] + c4[ii]*e3[Bars-i][ii];
if (ii==3) MapBuffer3[i]=c1[ii]*e6[Bars-i][ii] + c2[ii]*e5[Bars-i][ii] + c3[ii]*e4[Bars-i][ii] + c4[ii]*e3[Bars-i][ii];
if (ii==4) MapBuffer4[i]=c1[ii]*e6[Bars-i][ii] + c2[ii]*e5[Bars-i][ii] + c3[ii]*e4[Bars-i][ii] + c4[ii]*e3[Bars-i][ii];
if (ii==5) MapBuffer5[i]=c1[ii]*e6[Bars-i][ii] + c2[ii]*e5[Bars-i][ii] + c3[ii]*e4[Bars-i][ii] + c4[ii]*e3[Bars-i][ii];
if (ii==6) MapBuffer6[i]=c1[ii]*e6[Bars-i][ii] + c2[ii]*e5[Bars-i][ii] + c3[ii]*e4[Bars-i][ii] + c4[ii]*e3[Bars-i][ii];
}
}

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

Similar scripts

T3

This indicator computes a sophisticated triple exponential moving average using a recursive zero-lag filter to balance high reactivity with noise reduction across multiple time horizons.

T3 Taotra_v1

This indicator utilizes a recursive weighted smoothing algorithm to calculate multiple nested T3 price averages, providing filtered trend momentum across different timeframes.

T3 Taotra2

This indicator utilizes a triple-weighted recursive smoothing algorithm to generate multiple polynomial-based moving averages that filter market noise while preserving trend integrity.

T3 Bands2

T3_v2

This indicator calculates a multi-stage smoothed moving average by applying six successive weighted recursive filters to minimize price noise and lag.

T3 THV

This indicator utilizes a triple-smoothed moving average calculation to provide high-fidelity trend tracking while minimizing market noise through recursive weighting.

T3_v3

This indicator employs a nested recursive smoothing algorithm to generate a high-fidelity trend line by filtering price volatility through multiple sequential weight calculations.

palka2

The indicator calculates a dual-point arithmetic mean by averaging current price coordinates with historical offsets to highlight structural shifts.

T3_TCF_v1

This indicator utilizes a multi-stage smoothing algorithm and Fibonacci-based continuation factors to isolate trend momentum through recursive differential analysis.

Heiken_Ashi_Smoothed_006

This indicator synthesizes moving average price components into smoothed Heiken Ashi candles to isolate underlying momentum trends from market noise.

Heiken_Ashi_Smoothed_v3

Comments