i-Regr[1]
Download script![i-Regr[1]](/img/5335)
This technical indicator is designed to analyze price action by creating a sophisticated mathematical "best-fit" curve over historical data. Unlike standard moving averages that simply follow the price, this tool attempts to model the underlying trajectory of the market using advanced polynomial regression.
Core Logic Overview
The script functions by calculating a smooth trend line that accounts for the curvature of price movements. It treats the market's recent history as a set of coordinates and uses complex matrix algebra to determine the most accurate mathematical path through those points.
Key Components of the Process:
- Data Collection and Weighting: The tool looks back at a specific number of past bars (defined by the user) to gather historical closing prices. It creates a weighted summary of these prices to establish a foundation for the trend analysis.
- Polynomial Matrix Calculation: Instead of a simple straight line, the script uses a "degree" setting to determine how many curves the trend line can make. It builds a mathematical matrix to solve for the variables of a polynomial equation. This allows the indicator to adapt to more complex market shapes—from slight bends to deeper arcs.
- Gaussian Elimination: To find the most accurate curve, the script utilizes a process called Gaussian Elimination. This is a rigorous algebraic method used to solve systems of linear equations, ensuring that the resulting trend line minimizes the distance between itself and the actual price points as much as possible.
- Trend Line Generation: Once the math is finalized, the tool projects a primary trend line (the "best fit") onto your chart. This represents the mathematical "path of least resistance" for the current price action.
- Dynamic Volatility Channels: Beyond just showing the central trend, the script calculates the standard deviation of the price relative to that new curve. It then generates two secondary lines:
- An Upper Bound: The trend line plus a specific margin of volatility.
- A Lower Bound: The trend line minus that same margin of volatility.
Visual Output
The result is a three-line visual system: a central trajectory representing the smoothed mathematical trend, flanked by an upper and lower channel. This provides a clear picture of where the "core" price movement is heading while simultaneously defining a corridor of expected volatility based on historical behavior.
Miscellaneous
19
Views
0
Downloads
0
Favorites
i-Regr[1]
//----
#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 LimeGreen
#property indicator_color2 Gold
#property indicator_color3 Gold
extern int degree = 3;
extern double kstd = 2.0;
extern int bars = 250;
extern int shift = 0;
//-----
double fx[],sqh[],sql[];
double ai[10,10],b[10],x[10],sx[20];
double sum;
int ip,p,n,f;
double qq,mm,tt;
int ii,jj,kk,ll,nn;
double sq;
int i0 = 0;
/*
void clear()
{
int total = ObjectsTotal();
for (int i=total-1; i >= 0; i--)
{
string name = ObjectName(i);
if (StringFind(name, prefix) == 0) ObjectDelete(name);
}
}
*/
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int init()
{
SetIndexBuffer(0, fx); // Áóôåðû ìàññèâîâ èíäèêàòîðà
SetIndexBuffer(1, sqh);
SetIndexBuffer(2, sql);
SetIndexStyle(0, DRAW_LINE);
SetIndexStyle(1, DRAW_LINE);
SetIndexStyle(2, DRAW_LINE);
SetIndexEmptyValue(0, 0.0);
SetIndexEmptyValue(1, 0.0);
SetIndexEmptyValue(2, 0.0);
SetIndexShift(0, shift);
SetIndexShift(1, shift);
SetIndexShift(2, shift);
return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{
//clear();
return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int start()
{
if (Bars < bars) return;
//----
int mi; // ïåðåìåííàÿ èñïîëüçóþùàÿñÿ òîëüêî â start
ip = bars;
p=ip; // òèïà ïðèñâàèâàíèå
sx[1]=p+1; // ïðèìå÷àíèå - [] - îçíà÷àåò ìàññèâ
nn = degree+1;
SetIndexDrawBegin(0, Bars-p-1);
SetIndexDrawBegin(1, Bars-p-1);
SetIndexDrawBegin(2, Bars-p-1);
//----------------------sx-------------------------------------------------------------------
for(mi=1;mi<=nn*2-2;mi++) // ìàòåìàòè÷åñêîå âûðàæåíèå - äëÿ âñåõ mi îò 1 äî nn*2-2
{
sum=0;
for(n=i0;n<=i0+p;n++)
{
sum+=MathPow(n,mi);
}
sx[mi+1]=sum;
}
//----------------------syx-----------
for(mi=1;mi<=nn;mi++)
{
sum=0.00000;
for(n=i0;n<=i0+p;n++)
{
if(mi==1) sum+=Close[n];
else sum+=Close[n]*MathPow(n,mi-1);
}
b[mi]=sum;
}
//===============Matrix=======================================================================================================
for(jj=1;jj<=nn;jj++)
{
for(ii=1; ii<=nn; ii++)
{
kk=ii+jj-1;
ai[ii,jj]=sx[kk];
}
}
//===============Gauss========================================================================================================
for(kk=1; kk<=nn-1; kk++)
{
ll=0;
mm=0;
for(ii=kk; ii<=nn; ii++)
{
if(MathAbs(ai[ii,kk])>mm)
{
mm=MathAbs(ai[ii,kk]);
ll=ii;
}
}
if(ll==0) return(0);
if (ll!=kk)
{
for(jj=1; jj<=nn; jj++)
{
tt=ai[kk,jj];
ai[kk,jj]=ai[ll,jj];
ai[ll,jj]=tt;
}
tt=b[kk];
b[kk]=b[ll];
b[ll]=tt;
}
for(ii=kk+1;ii<=nn;ii++)
{
qq=ai[ii,kk]/ai[kk,kk];
for(jj=1;jj<=nn;jj++)
{
if(jj==kk) ai[ii,jj]=0;
else ai[ii,jj]=ai[ii,jj]-qq*ai[kk,jj];
}
b[ii]=b[ii]-qq*b[kk];
}
}
x[nn]=b[nn]/ai[nn,nn];
for(ii=nn-1;ii>=1;ii--)
{
tt=0;
for(jj=1;jj<=nn-ii;jj++)
{
tt=tt+ai[ii,ii+jj]*x[ii+jj];
x[ii]=(1/ai[ii,ii])*(b[ii]-tt);
}
}
//===========================================================================================================================
for(n=i0;n<=i0+p;n++)
{
sum=0;
for(kk=1;kk<=degree;kk++)
{
sum+=x[kk+1]*MathPow(n,kk);
}
fx[n]=x[1]+sum;
}
//-----------------------------------Std-----------------------------------------------------------------------------------
sq=0.0;
for(n=i0;n<=i0+p;n++)
{
sq+=MathPow(Close[n]-fx[n],2);
}
sq=MathSqrt(sq/(p+1))*kstd;
for(n=i0;n<=i0+p;n++)
{
sqh[n]=fx[n]+sq;
sql[n]=fx[n]-sq;
}
return(0);
}
//+------------------------------------------------------------------+
Comments