T3 Taotra_v1

Download script
T3 Taotra_v1

This script provides a sophisticated technical analysis tool designed to track price movements on a trading chart. Rather than using standard moving averages, which can often be lagging and "late" to the current market reality, this tool utilizes a mathematical smoothing technique known as the T3.

Core Concept: Enhanced Smoothing

The primary goal of this logic is to create a trend line that is exceptionally smooth while remaining highly responsive to new price changes. It achieves this by layering multiple levels of calculation on top of one another.

To do this, the script follows these key logical steps:

  • Weighting System: The tool uses a specific "coefficient" (a user-definable value) to determine how much weight to give to new data versus historical data. This allows the lines to be adjusted for different trading styles—making them either very "tight" and responsive or broader and more stable.
  • Multi-Stage Filtering: The script processes price data through six distinct layers of calculation. Each layer takes the result of the previous one and applies a new smoothing formula. By passing the data through these successive stages, the "noise" of the market (minor, erratic price spikes) is filtered out, leaving behind a clearer view of the underlying trend.
  • Dynamic Period Adjustments: The logic calculates internal "weights" based on the periods provided by the user. It automatically normalizes these periods to ensure that even if very small numbers are entered, the math remains consistent and stable across all six layers.

Visual Output

The result of this logic is the generation of six different trend lines, each plotted in a unique color (Yellow, Red, Magenta, Aqua, Green, and Blue).

Because each line is derived from the same sophisticated smoothing engine but uses different period settings, they provide a multi-layered perspective on market momentum. Traders can use these various lines to identify:

  1. Trend Direction: Seeing which way the primary lines are leaning.
  2. Momentum Strength: Observing how quickly the lines react to price shifts.
  3. Support and Resistance: Identifying "zones" where multiple lines cluster together, often signaling significant price levels.

In summary, this script replaces basic moving averages with a high-precision smoothing algorithm that seeks to provide a cleaner, more accurate representation of market trends by filtering out noise through a multi-stage mathematical process.

Miscellaneous
Implements a curve of type %1
10 Views
0 Downloads
0 Favorites
T3 Taotra_v1 
//+------------------------------------------------------------------+
//| 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 Green
#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,1,Green);
SetIndexStyle(5,DRAW_LINE,STYLE_SOLID,1,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

This indicator calculates a multi-layered weighted moving average using recursive smoothing coefficients to filter market noise and identify trend velocity.

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