AbsoluteStrenghtHisto_v1_002

Download script
Author: Copyright � 2006, TrendLaboratory Ltd.
AbsoluteStrenghtHisto_v1_002

The AbsoluteStrength indicator is designed to provide a visual representation of market sentiment by measuring the relative power between buying pressure (Bulls) and selling pressure (Bears). Instead of just showing price action, it calculates the "strength" of each side to help traders identify which force is currently dominating the market.

Core Logic and Methodology

The script operates by processing market data through several distinct layers:

1. Data Calculation Modes The indicator can interpret market strength in two different ways depending on the user's selection:

  • RSI Method: This approach looks at the immediate change in price between the current period and the previous period. It isolates whether the price moved up or down and quantifies that momentum.
  • Stochastic Method: This approach takes a broader view by looking at the highest highs and lowest lows over a specific timeframe. It measures where the current price sits relative to that range—essentially determining if the price is "stretched" toward the top (buying strength) or the bottom (selling strength).

2. Smoothing and Averaging Raw market data is often "noisy" and erratic. To create a reliable trend, the script applies multiple layers of mathematical smoothing:

  • It first calculates base values for both Bulls and Bears.
  • It then applies a Moving Average to these values to filter out minor price fluctuations.
  • A final smoothing pass is applied to ensure the resulting lines are fluid and representative of the broader trend rather than instant spikes.

3. Visualization Styles (Histogram Logic) The script offers several ways to display this "strength" data on your chart, allowing you to choose the visual style that best fits your trading strategy:

  • Standard Smoothing: Displays the calculated bull and bear strengths as distinct lines.
  • Opposite Symmetry: Adjusts the values so they mirror each other, making it easier to see the balance of power (when one side goes up, the other reflects downward).
  • Dominance Tracking: Highlights which side is winning. In these modes, the indicator identifies the stronger force and displays it prominently while neutralizing the weaker force (setting it to zero). This provides a clear "winner-takes-all" visual of the current market sentiment.

Summary for the User

In simple terms, this script acts as a momentum scale. It looks at price movement (either through immediate change or relative range) and decides who is "winning" the tug-of-war: the buyers or the sellers. By smoothing this data, it removes the "jitter" of the market to show you a clear, readable trend of absolute strength.

Indicators Used
Moving average indicatorMoving average indicator
Miscellaneous
Implements a curve of type %1
8 Views
0 Downloads
0 Favorites
AbsoluteStrenghtHisto_v1_002 
//+------------------------------------------------------------------+
//|                                          AbsoluteStrength_v1.mq4 |
//|                           Copyright © 2006, TrendLaboratory Ltd. |
//|            http://finance.groups.yahoo.com/group/TrendLaboratory |
//|                                       E-mail: igorad2004@list.ru |
//+------------------------------------------------------------------+
//| Modifications:                                                   |
//| - AbsoluteStrengthHisto_v1, 2006/06/26:                          |
//|   Put in Histogram form with 2 level lines                       |
//|   ph_bresson@yahoo.com                                           |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, TrendLaboratory Ltd."
#property link      "http://finance.groups.yahoo.com/group/TrendLaboratory"

#property indicator_separate_window
#property indicator_buffers   4
#property indicator_color1    Blue
#property indicator_width1    4 
#property indicator_color2    Red
#property indicator_width2    4
#property indicator_color3    Blue
#property indicator_width3    2 
#property indicator_color4    Red
#property indicator_width4    2

//---- input parameters
extern int       Mode   =  0; // 0-RSI method; 1-Stoch method
extern int       Length =  9; // Period
extern int       Smooth =  1; // Period of smoothing
extern int       Signal =  4; // Period of Signal Line
extern int       Price  =  0; // Price mode : 0-Close,1-Open,2-High,3-Low,4-Median,5-Typical,6-Weighted
extern int       ModeMA =  3; // Mode of Moving Average
extern int       Mode_Histo  = 3; 
//---- buffers
double Bulls[];
double Bears[];
double AvgBulls[];
double AvgBears[];
double SmthBulls[];
double SmthBears[];
double SigBulls[];
double SigBears[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   IndicatorBuffers(8);
   SetIndexStyle(0,DRAW_HISTOGRAM,EMPTY,4);
   SetIndexBuffer(0,SmthBulls);
   SetIndexStyle(1,DRAW_HISTOGRAM,EMPTY,4);
   SetIndexBuffer(1,SmthBears);

   SetIndexStyle(2,DRAW_LINE,EMPTY,2);
   SetIndexBuffer(2,SigBulls);
   SetIndexStyle(3,DRAW_LINE,EMPTY,2);
   SetIndexBuffer(3,SigBears);

   SetIndexBuffer(4,Bulls);
   SetIndexBuffer(5,Bears);
   SetIndexBuffer(6,AvgBulls);
   SetIndexBuffer(7,AvgBears);
//---- name for DataWindow and indicator subwindow label
   string short_name="AbsoluteStrengthHistogram("+Mode+","+Length+","+Smooth+","+Signal+",,"+ModeMA+")";
   IndicatorShortName(short_name);
   SetIndexLabel(0,"Bulls");
   SetIndexLabel(1,"Bears");
   SetIndexLabel(2,"Bulls");
   SetIndexLabel(3,"Bears");      

//----
   SetIndexDrawBegin(0,Length+Smooth+Signal);
   SetIndexDrawBegin(1,Length+Smooth+Signal);
   SetIndexDrawBegin(2,Length+Smooth+Signal);
   SetIndexDrawBegin(3,Length+Smooth+Signal);
 
   SetIndexEmptyValue(0,0.0);
   SetIndexEmptyValue(1,0.0);
   SetIndexEmptyValue(2,0.0);
   SetIndexEmptyValue(3,0.0);
   SetIndexEmptyValue(4,0.0);
   SetIndexEmptyValue(5,0.0);
   SetIndexEmptyValue(6,0.0);
   SetIndexEmptyValue(7,0.0);



   return(0);
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int      shift, limit, counted_bars=IndicatorCounted();
   double   Price1, Price2, smax, smin;
//---- 
   if ( counted_bars < 0 ) return(-1);
   if ( counted_bars ==0 ) limit=Bars-Length+Smooth+Signal-1;
   if ( counted_bars < 1 ) 
   for(int i=1;i<Length+Smooth+Signal;i++) 
   {
   Bulls[Bars-i]=0;    
   Bears[Bars-i]=0;  
   AvgBulls[Bars-i]=0;    
   AvgBears[Bars-i]=0;  
   SmthBulls[Bars-i]=0;    
   SmthBears[Bars-i]=0;  
   SigBulls[Bars-i]=0;    
   SigBears[Bars-i]=0;  
   }
   
   
   
   if(counted_bars>0) limit=Bars-counted_bars;
   limit--;
   
   for( shift=limit; shift>=0; shift--)
      {
      Price1 = iMA(NULL,0,1,0,0,Price,shift);
      Price2 = iMA(NULL,0,1,0,0,Price,shift+1); 
      
         if (Mode==0)
         {
         Bulls[shift] = 0.5*(MathAbs(Price1-Price2)+(Price1-Price2));
         Bears[shift] = 0.5*(MathAbs(Price1-Price2)-(Price1-Price2));
         }
        
         if (Mode==1)
         {
         smax=High[Highest(NULL,0,MODE_HIGH,Length,shift)];
         smin=Low[Lowest(NULL,0,MODE_LOW,Length,shift)];
         
         Bulls[shift] = Price1 - smin;
         Bears[shift] = smax - Price1;
         }
      }
      
      for( shift=limit; shift>=0; shift--)
      {
      AvgBulls[shift]=iMAOnArray(Bulls,0,Length,0,ModeMA,shift);     
      AvgBears[shift]=iMAOnArray(Bears,0,Length,0,ModeMA,shift);
      }
      
      for( shift=limit; shift>=0; shift--)
      {
      SmthBulls[shift]=iMAOnArray(AvgBulls,0,Smooth,0,ModeMA,shift);     
      SmthBears[shift]=iMAOnArray(AvgBears,0,Smooth,0,ModeMA,shift);
      }

      if(Mode_Histo == 1)
      {
         for( shift=limit; shift>=0; shift--)
         {
            if(SmthBulls[shift]-SmthBears[shift]>0)
            {
               SetIndexStyle(0,DRAW_HISTOGRAM,EMPTY,5);
               SetIndexStyle(1,DRAW_LINE,EMPTY,2);
               SmthBears[shift]= SmthBears[shift]/Point;
               SmthBulls[shift]= SmthBulls[shift]/Point;
            }
            else
            {
               SetIndexStyle(1,DRAW_HISTOGRAM,EMPTY,5);
               SetIndexStyle(0,DRAW_LINE,EMPTY,2);
               SmthBears[shift]= SmthBears[shift]/Point;
               SmthBulls[shift]= SmthBulls[shift]/Point;
            }
         }  //end for( shift=limit; shift>=0; shift--)
      }     // end if(Mode_Histo == 1)
      else
      if(Mode_Histo == 2)
      {
         for( shift=limit; shift>=0; shift--)
         {
            if(SmthBulls[shift]-SmthBears[shift]>0)
            {
               SmthBears[shift]=-SmthBears[shift]/Point;
               SmthBulls[shift]= SmthBulls[shift]/Point;
            }
            else
            {
               SmthBulls[shift]=-SmthBulls[shift]/Point;
               SmthBears[shift]= SmthBears[shift]/Point;
            }
         }  //end for( shift=limit; shift>=0; shift--)      
      }     //end if(Mode_Histo == 2)
      else
      if(Mode_Histo == 3)
      {
         for( shift=limit; shift>=0; shift--)
         {
            SigBulls[shift]=  SmthBulls[shift];
            SigBears[shift]=  SmthBears[shift];            
            if(SmthBulls[shift]-SmthBears[shift]>0)
               SmthBears[shift]=0;
            else
               SmthBulls[shift]=0;  
         }  //end for( shift=limit; shift>=0; shift--)      
      }     //end if(Mode_Histo == 3)
      else
      if(Mode_Histo == 4)
      {
         for( shift=limit; shift>=0; shift--)
         {
            if(SmthBulls[shift]-SmthBears[shift]>0)
            {
               SigBears[shift]=  SmthBears[shift];
               SmthBears[shift]=0;
            }
            else
            {
               SigBulls[shift]=  SmthBulls[shift];
               SmthBulls[shift]=0;         
            }
         }  //end for( shift=limit; shift>=0; shift--)      
      }     //end if(Mode_Histo == 4)
      
   return(0);
  }
//+------------------------------------------------------------------+

Similar scripts

AbsoluteStrenghtHisto_v1

This indicator quantifies market pressure by calculating the net distance between current price action and extreme historical ranges, filtering the resulting bullish and bearish components through multi-stage moving average smoothing.

AbsoluteStrenghtHisto_v1_v2

This indicator quantifies market sentiment by decomposing price velocity into polarized bull and bear components using either derivative-based changes or stochastic range extremes.

AbsoluteStrenghtHisto_v1_v4

This indicator quantifies market pressure by calculating the divergence between bullish and bearish price velocities, employing either RSI-based relative changes or Stochastic-style range boundaries to visualize directional dominance.

AbsoluteStrenghtHisto_v1_v1

This indicator quantifies bullish and bearish dominance by calculating price deviations using either RSI-based velocity or Stochastic range proximity, then smoothing the resulting values into distinct histogram profiles.

AbsoluteStrength TimeFrame

This indicator quantifies bullish and bearish pressure by synthesizing price velocity, relative range positioning, or volatility expansion into smoothed momentum profiles.

AbsoluteStrength_v1

This indicator quantifies market dominance by calculating independent bullish and bearish force vectors through either price delta analysis or stochastic range expansion, subsequently applying triple-layered moving average smoothing to isolate pure trend velocity.

AbsoluteStrength TimeFrame_v1

This indicator quantifies market conviction by calculating bullish and bearish directional pressure through three distinct mathematical lenses: absolute price differential, stochastic range positioning, and high-low volatility extremes.

AbsoluteStrength_v1DH_001

This indicator quantifies market conviction by calculating the directional magnitude of price movement relative to historical extremes or immediate velocity, processed through multiple layers of moving average smoothing.

AbsoluteStrength_v1DH

This indicator quantifies directional dominance by calculating the divergence between current price action and historical extremes or previous price points using dual smoothing layers.

AbsoluteStrength_v1DH_002

This indicator quantifies directional pressure by calculating the divergence between current price action and historical extremes or relative shifts, utilizing multi-stage smoothing to identify momentum transitions.

turtlechanneli

This indicator plots three concurrent sets of Donchian Channels across long, medium, and short timeframes to identify volatility boundaries and price breakout points.

Comments