Center of GravityTrl

Download script
Center of GravityTrl

This script is designed to provide a sophisticated visual analysis of price movement by identifying the underlying "center of gravity" for financial assets. Instead of simply looking at where the price is currently moving, this tool attempts to calculate the structural path that the market is following based on historical data.

Core Logic and Methodology

The script functions through several distinct analytical stages:

1. Data Gathering and Weighting The tool begins by analyzing a specific window of past market bars (determined by user settings). Rather than treating every past price point as equally important, it applies a mathematical weighting system to the closing prices. This helps the indicator distinguish between recent trends and older historical data.

2. Matrix Construction and Mathematical Modeling At its core, the script utilizes complex linear algebra. It constructs a mathematical matrix to represent the relationship between time and price. By organizing this data into a grid-like structure, the script can perform "Gaussian elimination"—a process used to simplify complex systems of equations. This allows the tool to strip away market "noise" and isolate the primary trend line.

3. Trend Projection (The Center of Gravity) Once the matrix is simplified, the script solves for a specific polynomial curve. This curve represents the "Center of Gravity." In practical terms, this is the theoretical path that best fits the historical price action. It provides a smoothed, structural view of where the market is "balanced."

4. Volatility and Boundary Calculation To make the data useful for trading, the script doesn't just show one line; it also calculates the market's volatility. By measuring how far the actual price fluctuates away from the calculated Center of Gravity, it establishes two boundaries:

  • Upper Boundary: Represents the ceiling of the current price movement.
  • Lower Boundary: Represents the floor of the current price movement.

Visual Output

The resulting indicator provides a clear visual representation of market structure on your chart. By observing the relationship between the Center of Gravity line and its upper/lower boundaries, users can better perceive whether the market is expanding in volatility, contracting, or following a steady structural path. It essentially acts as a map of the "fair value" trend versus the current market noise.

Indicators Used
Standard Deviation indicator
Miscellaneous
Implements a curve of type %1
14 Views
0 Downloads
0 Favorites
Center of GravityTrl 
//+------------------------------------------------------------------+
//|                                            Center of Gravity.mq4 |
//| Original Code from NG3110@latchess.com                           |                                    
//| Linuxser 2007 for TSD    http://www.forex-tsd.com/               |
//+------------------------------------------------------------------+
#property  copyright "ANG3110@latchess.com"
//mod trailer
//---------ang_PR (Din)--------------------
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_color1 RoyalBlue
#property indicator_color2 LimeGreen
#property indicator_color3 LimeGreen
#property indicator_color4 Goldenrod
#property indicator_color5 Goldenrod
//-----------------------------------
extern int bars_back = 125;
extern int m = 2;
extern int i = 0;
extern double kstd = 2.0;
extern int sName = 1102;
//-----------------------
double fx[], sqh[], sql[], stdh[], stdl[];
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,y;
double sq, std;
//*******************************************
int init()
{
   IndicatorShortName("Center of Gravity");
   SetIndexStyle(0, DRAW_LINE);
   SetIndexBuffer(0, fx);
   SetIndexBuffer(1, sqh);
   SetIndexBuffer(2, sql);
   SetIndexBuffer(3, stdh);
   SetIndexBuffer(4, stdl);
   p = MathRound(bars_back);
   nn = m + 1;
   ObjectCreate("pr" + sName, 22, 0, Time[p], fx[p]);
   ObjectSet("pr" + sName, 14, 159);
   return(0);
}
//----------------------------------------------------------
int deinit()
{
   ObjectDelete("pr" + sName);
}
//**********************************************************************************************
int start()
{
   int mi;
//-------------------------------------------------------------------------------------------
   ip = iBarShift(Symbol(), Period(), ObjectGet("pr" + sName, OBJPROP_TIME1));
   p = bars_back; 
   sx[1] = p + 1;
   SetIndexDrawBegin(0, Bars - p - 1);
   SetIndexDrawBegin(1, Bars - p - 1);
   SetIndexDrawBegin(2, Bars - p - 1);
//   SetIndexDrawBegin(3, Bars - p - 1);
//   SetIndexDrawBegin(4, Bars - p - 1); 
//----------------------sx-------------------------------------------------------------------
   for(mi = 1; mi <= nn * 2 - 2; mi++)
   {
      sum = 0;
      for(n = i; n <= i + p; n++)
      {
         sum += MathPow(n, mi);
      }
      sx[mi + 1] = sum;
   }  
//----------------------syx-----------
   for(mi = 1; mi <= nn; mi++)
   {
      sum = 0.00000;
      for(n = i; n <= i + 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 = i; n <= i + p; n++)
   {
      sum = 0;
      for(kk = 1; kk <= m; kk++)
      {
         sum += x[kk + 1] * MathPow(n, kk);
      }
      fx[n] = x[1] + sum;
   } 
//-----------------------------------Std-----------------------------------------------------------------------------------
   sq = 0.0;
   for(n = i; n <= i + p; n++)
   {
      sq += MathPow(Close[n] - fx[n], 2);
   }
   sq = MathSqrt(sq / (p + 1)) * kstd;
   std = iStdDev(NULL, 0, p, MODE_SMA, 0, PRICE_CLOSE, i) * kstd;
   for(n = i,y=0; n <= i + p; n++)
   {
      sqh[n] = fx[n] + sq;
      sql[n] = fx[n] - sq;
      if(n==0){     stdh[n] =  sqh[n];
                    stdl[n] =  sql[n];
               }
   }



//-------------------------------------------------------------------------------
   ObjectMove("pr" + sName, 0, Time[p], fx[p]);
//----------------------------------------------------------------------------------------------------------------------------
   return(0);
}
//==========================================================================================================================

Similar scripts

COGSTOCH

Center of Gravity_v3

This indicator calculates a dynamic price trajectory by applying Gaussian elimination to solve for polynomial coefficients, establishing a statistical equilibrium path and its associated standard deviation envelopes.

i-regr

This indicator utilizes Gaussian elimination to solve for a variable-degree polynomial regression, constructing a volatility-adjusted price channel based on standard deviation.

Center of Gravity

This indicator employs a Gaussian elimination matrix to calculate the weighted center of gravity of price action, projecting an equilibrium trend line bounded by dynamic standard deviation channels.

Center of Gravity 1

This indicator utilizes a Gauss elimination matrix to perform high-order polynomial regression, mapping the underlying price curve and calculating dynamic variance bands for structural trend analysis.

COG THV

This indicator utilizes a Gauss elimination matrix to solve for polynomial coefficients, projecting price trends and calculating multi-layered standard deviation envelopes based on regression variance.

Center_Of_Gravity

This indicator utilizes a Gaussian elimination matrix to solve for polynomial coefficients of historical price action, constructing a smoothed trend line with dynamic standard deviation bands.

JB Center of Gravity

This indicator employs a Gaussian elimination matrix algorithm to calculate the underlying polynomial curve of price action, establishing a dynamic equilibrium point and variance-based volatility bands.

ang_PR (Din)-v1+SQStdN_v2

This indicator utilizes a Gaussian elimination matrix algorithm to perform polynomial regression on price data, generating dynamic upper and lower standard deviation envelopes.

trend_channel

i-Regr H&amp;L v2

The indicator utilizes Gaussian elimination to solve a system of linear equations, constructing multi-degree polynomial regression lines and channels based on high and low price extremes.

Comments