Center_Of_Gravity

Download script
Center_Of_Gravity

This script functions as a sophisticated technical analysis tool designed to identify the "Center of Gravity" within a specific timeframe of market price action. Rather than simply looking at moving averages, it uses a mathematical process to determine the underlying trend and the volatility surrounding that trend.

Core Logic Overview

The script operates by analyzing a set amount of historical data (defined by the user) to project a smoothed path of where the price "should" be based on its current momentum. It achieves this through three primary phases:

1. Data Summation and Preparation The script begins by gathering historical closing prices over a specific period. It calculates various sums of these prices, weighted by their position in time. This ensures that more recent price action is accounted for differently than older data, allowing the tool to understand the "weight" of current market sentiment.

2. The Matrix and Trend Calculation This is the most complex part of the logic. The script organizes the gathered data into a mathematical matrix. It then performs a process similar to regression analysis—specifically, it seeks to solve for a polynomial curve that best fits the existing price data.

  • Think of this as finding the "spine" of the price movement.
  • By solving these equations, the script identifies a smooth, continuous line (the Center of Gravity) that represents the most statistically significant path the price is currently taking.

3. Volatility and Standard Deviation Boundaries Once the "Center of Gravity" line is established, the script calculates the spread or "noise" around that line. It does this by:

  • Measuring the actual distance between the real market prices and the calculated Center of Gravity.
  • Applying a multiplier (standard deviation) to create boundaries.

Visual Output

The script generates several distinct visual components on the chart:

  • The Primary Line: The main "Center of Gravity" trend line.
  • Upper and Lower Channels: It creates two sets of boundaries (highs and lows). These represent the expected range of price movement.

Summary for the Trader

Instead of just telling you what the price did, this script attempts to model what the price is doing fundamentally. By identifying the "Center of Gravity," it helps traders filter out minor market fluctuations to see the broader trend, while the upper and lower boundaries provide a visual guide for potential overextended areas where the price might be deviating too far from its core equilibrium.

Indicators Used
Standard Deviation indicator
Miscellaneous
Implements a curve of type %1
10 Views
0 Downloads
0 Favorites
Center_Of_Gravity 
//+------------------------------------------------------------------+
//|                                            Center of Gravity.mq4 |
//| Original Code from NG3110@latchess.com                           |                                    
//| Linuxser 2007 for TSD    http://www.forex-tsd.com/               |
//+------------------------------------------------------------------+
#property  copyright "ANG3110@latchess.com"
//---------ang_PR (Din)--------------------
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_color1 Aqua
#property indicator_color2 Orange
#property indicator_color3 Lime
#property indicator_color4 Red
#property indicator_color5 Green
//-----------------------------------
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;
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; n <= i + p; n++)
   {
      sqh[n] = fx[n] + sq;
      sql[n] = fx[n] - sq;
      stdh[n] = fx[n] + std;
      stdl[n] = fx[n] - std;
   } 
//-------------------------------------------------------------------------------
   ObjectMove("pr" + sName, 0, Time[p], fx[p]);
//----------------------------------------------------------------------------------------------------------------------------
   return(0);
}
//==========================================================================================================================

Similar scripts

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 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.

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.

CentreOfGravityV2_v1

ang_PR (Din)-v1+SQStdN_v1

This indicator utilizes Gaussian elimination to solve a matrix of polynomial coefficients, creating a smoothed regression curve and dynamically calculated standard deviation boundaries.

ATM_LRCpath

This indicator employs a Gauss elimination matrix to calculate a high-order polynomial regression curve that maps price trajectory dynamics and projects dynamic volatility envelopes.

ang_PR (Din)-v2

The algorithm utilizes a Gaussian elimination matrix to solve for polynomial coefficients, projecting price trajectories based on weighted historical data points.

ang_PR_(Din)-v1_v1

This indicator utilizes Gaussian elimination to solve a system of linear equations for polynomial regression, projecting price trends based on historical momentum.

ang_PR_(Din)-v1

This indicator employs a Gaussian elimination algorithm to solve for polynomial coefficients, generating a projected trend line based on historical price velocity.

Center of GravityTrl

This indicator calculates a dynamic price trend by applying a multi-degree polynomial matrix to historical closing prices to determine the weighted geometric center of gravity.

Comments