CCM3_v2

Download script
CCM3_v2

This script functions as a sophisticated visual indicator designed to analyze price action by evaluating the "body," "upper shadow," and "lower shadow" of trading candles. Instead of simply looking at price movement, it breaks down the anatomy of each candle to determine how aggressively buyers or sellers are interacting with the market.

Core Logic Overview

The indicator works by categorizing the relationship between a candle's opening/closing prices and its high/low extremes. It processes this data through three distinct layers:

1. Data Decomposition The script measures three specific components for every candle over a rolling period:

  • The Body: The distance between the open and close prices.
  • The Upper Shadow: The distance between the highest price reached and the top of the candle body.
  • The Lower Shadow: The distance between the lowest price reached and the bottom of the candle body.

2. Volatility and Boundary Analysis To provide context to these measurements, the script calculates standard deviations for each of the three components (Body, Upper Shadow, and Lower Shadow). It establishes dynamic "boundaries" (similar to Bollinger Bands) for each component. This allows the tool to recognize what constitutes a "normal" move versus an "extreme" move in the current market environment.

3. Candle Coding and Weighted Scoring This is the heart of the script's logic. Every candle is assigned a numerical "code" based on how it relates to those dynamic boundaries:

  • It checks if the body size is small, medium, or large relative to recent history.
  • It determines if the upper shadow is significant enough to suggest rejection of higher prices.
  • It evaluates if the lower shadow suggests a rejection of lower prices.

The script then applies a complex mathematical weight (a weighting factor) to these codes over a sequence of candles. This means that more recent price actions have a different level of influence on the final result than older ones, creating a smoothed "momentum" score.

Visual Representation

The logic culminates in three specific visual outputs on the chart:

  • Main Signal Line: A calculated average of the weighted scores, providing a smooth representation of market sentiment.
  • Up/Down Histograms: These highlight the immediate strength of the current candle's signal, showing whether the most recent price action is tilting toward positive or negative pressure compared to the preceding bar.

In essence, this tool translates raw price data into a "sentiment score" by measuring how much effort the market is putting into pushing prices up or down relative to the standard behavior of the last several dozen bars.

Miscellaneous
Implements a curve of type %1
13 Views
0 Downloads
0 Favorites
CCM3_v2 
//+------------------------------------------------------------------+
//| CCM3.mq4 
//| Ramdass - Conversion only
//+------------------------------------------------------------------+
#property  copyright "Author := Keny"
#property indicator_separate_window
#property indicator_buffers 3
#property indicator_color1 DodgerBlue
#property indicator_color2 Green
#property indicator_color3 Red
//---- input parameters
extern int n=6;
extern int len=9;
extern double StdUp=0.5;
extern double StdDown=-0.5;
extern double a0=0.0;
extern double b0=0.0;
extern double c0=-1.0;
extern int CountBars=200;
//---- buffers
double SigL[];
double Up[];
double Dw[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   string short_name;
//---- indicator line
   IndicatorBuffers(3);
   SetIndexBuffer(0,SigL);
   SetIndexBuffer(1,Up);
   SetIndexBuffer(2,Dw);
   SetIndexStyle(0,DRAW_LINE,0,2);
   SetIndexStyle(1,DRAW_HISTOGRAM,0,2);
   SetIndexStyle(2,DRAW_HISTOGRAM,0,2);
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| CCM + Digi                                                       |
//+------------------------------------------------------------------+
int start()
  {
   if (CountBars>=Bars) CountBars=Bars;
   SetIndexDrawBegin(0,Bars-CountBars+39);
   SetIndexDrawBegin(1,Bars-CountBars+39);
   SetIndexDrawBegin(2,Bars-CountBars+39);
   int shift,i,i2,cnt,len1,k;
   int counted_bars=IndicatorCounted();
   double value1,value3,M1,M2,M3,Hi1,Lo1,price,code;
   double b1,b2,u1,u2,l1,l2,V0,V1,V2,V3;
   double xOC,xHMOC,xMOCL,EMA0,EMAcode,cci;
   double code1[61],OC[61],HMOC[61],MOCL[61],MAxOC[61],MAxHMOC[61],MAxMOCL[61],WF[60];
//----
   if(Bars<=60) return(0);
   len1=len;
   if (len1>60) len1=60;

//---- initial zero
   if(counted_bars<60)
     {
      for(i=1;i<=0;i++) SigL[CountBars-i]=0.0;
      for(i=1;i<=0;i++) Up[CountBars-i]=0.0;
      for(i=1;i<=0;i++) Dw[CountBars-i]=0.0;
     }
//----
   for(i=0; i<=n-1; i++)
     {
      WF[i]=MathPow(i-b0,a0)*MathExp(c0*(i-b0));
     }

   shift=CountBars-1;

   while(shift>=0)
     {
      for(i=len1-1; i>=1; i--)
        { //ïåðåïèñûâàåì ìàññèâû - äëÿ áîëëèíäæåðà
         OC[i]=OC[i-1];
         HMOC[i]=HMOC[i-1];
         MOCL[i]=MOCL[i-1];
         MAxOC[i]=MAxOC[i-1];
         MAxHMOC[i]=MAxHMOC[i-1];
         MAxMOCL[i]=MAxMOCL[i-1];
        }
      for(i=38; i>=1; i--)
        {
         code1[i]=code1[i-1];
        }
      EMA0=EMAcode;

      OC[0]=MathAbs(Open[shift]-Close[shift]);
      HMOC[0]=High[0]-MathMax(Open[shift],Close[shift]);
      MOCL[0]=MathMin(Open[shift],Close[shift])-Low[shift];
      MAxOC[0]=(MAxOC[1]-OC[len1-1])+OC[0];
      MAxHMOC[0]=MAxHMOC[1]-HMOC[len-1]+HMOC[0];
      MAxMOCL[0]=MAxMOCL[1]-MOCL[len1-1]+MOCL[0];
      xOC=MAxOC[0]/len1;
      xHMOC=MAxHMOC[0]/len1;
      xMOCL=MAxMOCL[0]/len1;
      V1=0;
      V2=0;
      V3=0;
      for(i=0; i<=len1-1; i++)
        {
         V0=OC[i]-xOC;
         V0=V0*V0;
         V1=V1+V0;
         V0=HMOC[i]-xHMOC;
         V0=V0*V0;
         V2=V2+V0;
         V0=MOCL[i]-xMOCL;
         V0=V0*V0;
         V3=V3+V0;
        }

      V1=V1/len1;
      V1=MathSqrt(V1);
      V2=V2/len1;
      V2=MathSqrt(V2);
      V3=V3/len1;
      V3=MathSqrt(V3);
      b1=xOC+StdDown*V1; //b1,b2-BB äëÿ òåë
      b2=xOC+StdUp*V1;
      u1=xHMOC+StdDown*V2;//u1,u2-BB äëÿ âåðõíåé òåíè
      u2=xHMOC+StdUp*V2;
      l1=xMOCL+StdDown*V3;//l1,l2-BB äëÿ íèæíåé òåíè
      l2=xMOCL+StdUp*V3;
      code1[0]=0.0;
      for(i=0; i<=n-1; i++) //êîäèðóåì ñâå÷ó
        {
         Hi1=High[shift]; Lo1=Low[shift];
         for(k=shift; k<=shift+n-1; k++)
           {
            price=High[k];
            if(Hi1<=price) Hi1=price;
            price=Low[k];
            if(Lo1>price)  Lo1=price;
           }
         code=0;
         if (Open[shift+i]<Close[shift]) code=64;
         if (Close[shift]==Open[shift+i])
           {
            if(Hi1-MathMax(Close[shift],Open[shift+i])>=MathMin(Close[shift],Open[shift+i])-Lo1)code=64;
           }
         if (code>=64)
           {
            //if (Open[shift+i]==Close[shift]) code=code;
            if((MathAbs(Open[shift+i]-Close[shift+i])<b1) && (MathAbs(Open[shift+i]-Close[shift])>0))code=code+16;
            if((MathAbs(Open[shift+i]-Close[shift])>=b1) && ((MathAbs(Open[shift+i]-Close[shift])<b2)))code=code+32;
            if (MathAbs(Open[shift+i]-Close[shift])>=b2) code=code+48;
           }
         if (code<64)
           {
            if (Open[shift+i]==Close[shift]) code=code+48;
            if((MathAbs(Open[shift+i]-Close[shift])<b1) && (MathAbs(Open[shift+i]-Close[shift])>0))code=code+32;
            if((MathAbs(Open[shift+i]-Close[shift])>=b1) && ((MathAbs(Open[shift+i]-Close[shift+i])<b2)))code=code+16;
            //if (MathAbs(Open[shift+i]-Close[shift])>=b2) code=code;
           }
         if (Hi1-MathMax(Open[shift+i],Close[shift])<u1 && Hi1-MathMax(Open[shift+i],Close[shift])>0) code=code+4;
         if (Hi1-MathMax(Open[shift+i],Close[shift])>=u1 && Hi1-MathMax(Open[shift+i],Close[shift])<u2) code=code+8;
         if (Hi1-MathMax(Open[shift+i],Close[shift])>=u2) code=code+12;
         if (MathMin(Open[shift+i],Close[shift])-Lo1==0) code=code+3;
         if (MathMin(Open[shift+i],Close[shift])-Lo1<l1 && MathMin(Open[shift+i],Close[shift])-Lo1>0) code=code+2;
         if (MathMin(Open[shift+i],Close[shift])-Lo1>=l1 && MathMin(Open[shift+i],Close[shift])-Lo1<l2) code=code+1;
         code1[0]=code1[0]+(code-63)*WF[i];
        }
      cnt=cnt+1;
      if (cnt>39) //ñãëàæèâàåì ñ ïîìîùüþ FATL îò Finvare
        {
         SigL[shift]=
         0.4360409450*code1[0]
         +0.3658689069*code1[1]
         +0.2460452079*code1[2]
         +0.1104506886*code1[3]
         -0.0054034585*code1[4]
         -0.0760367731*code1[5]
         -0.0933058722*code1[6]
         -0.0670110374*code1[7]
         -0.0190795053*code1[8]
         +0.0259609206*code1[9]
         +0.0502044896*code1[10]
         +0.0477818607*code1[11]
         +0.0249252327*code1[12]
         -0.0047706151*code1[13]
         -0.0272432537*code1[14]
         -0.0338917071*code1[15]
         -0.0244141482*code1[16]
         -0.0055774838*code1[17]
         +0.0128149838*code1[18]
         +0.0226522218*code1[19]
         +0.0208778257*code1[20]
         +0.0100299086*code1[21]
         -0.0036771622*code1[22]
         -0.0136744850*code1[23]
         -0.0160483392*code1[24]
         -0.0108597376*code1[25]
         -0.0016060704*code1[26]
         +0.0069480557*code1[27]
         +0.0110573605*code1[28]
         +0.0095711419*code1[29]
         +0.0040444064*code1[30]
         -0.0023824623*code1[31]
         -0.0067093714*code1[32]
         -0.0072003400*code1[33]
         -0.0047717710*code1[34]
         +0.0005541115*code1[35]
         +0.0007860160*code1[36]
         +0.0130129076*code1[37]
         +0.0040364019*code1[38];
        }
      Up[shift]=0.0; Dw[shift]=0.0;
      if (code1[0]>=code1[1]) {Up[shift]=code1[0];} else {Dw[shift]=code1[0];}
      shift--;
     }
   return(0);
  }
//+------------------------------------------------------------------+

Similar scripts

CCM3

This indicator quantifies market pressure by applying a weighted polynomial decay to candlestick geometry, adjusted via standard deviation bands of price action components.

CCM2_v1

This indicator utilizes a custom weighted sum of price action dynamics, calculating standard deviation bounds on body-to-wick ratios to generate a smoothed momentum signal.

CCM3_v1

This indicator calculates a multi-dimensional momentum signal by quantifying price action intensity relative to dynamic volatility bands and applying a weighted decay function over historical candles.

CCM2_001

This indicator quantifies price action intensity by calculating the weighted variance of body sizes and wicks against dynamic volatility bands, processed through a multi-coefficient linear regression.

CCM2_v2

This indicator quantifies price action by calculating weighted volatility deviations of body, upper shadow, and lower shadow components, then applies a multi-factor linear regression filter to identify structural momentum.

CCM2

The indicator quantifies price action dynamics by calculating weighted deviations of candle bodies, upper wicks, and lower wicks relative to standard deviation bands, processed through a sophisticated linear regression filter.

FATL.mq4

The indicator computes a complex weighted sum of the previous 39 closing prices using specific coefficients to smooth out price fluctuations and highlight underlying trend direction.

FATL

The algorithm calculates a weighted moving average by applying specific coefficients to a sequence of 39 historical closing prices to filter market noise.

Digits_comment_v1

This indicator calculates four distinct price streams by applying unique fixed-weight coefficients to multi-period historical closing data to identify underlying trend components.

Digits_comment_v2

The code calculates four distinct price overlays by applying complex weighted linear combinations of historical closing prices to identify diverse market momentum profiles.

DTM

This indicator quantifies market velocity by calculating the divergence between two distinct sets of weighted linear combinations of historical price data.

Comments