AbsoluteStrenghtHisto_v1

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

The AbsoluteStrength indicator is designed to measure the momentum and "dominance" of market participants by calculating the relative power between buyers (Bulls) and sellers (Bears). Instead of simply looking at price movement, it attempts to isolate the individual strength of each side to provide a clearer picture of market sentiment.

Core Calculation Logic

The tool operates using two primary calculation methods that you can choose from:

  • Method 0 (RSI Style): This focuses on the direct velocity of price changes. It looks at the difference between current and previous prices to determine how much "push" is being applied by each side.
  • Method 1 (Stochastic Style): This measures where the current price sits relative to recent highs and lows. It calculates the distance between the current price and the recent extremes to see if the market is overextended or has significant room to move in one direction.

Data Processing & Smoothing

Once the raw strength for bulls and bears is identified, the script performs several layers of refinement to make the data readable:

  1. Averaging: It applies a moving average to the raw bull and bear values to filter out minor "noise" or erratic price spikes.
  2. Smoothing: A secondary smoothing pass is applied to ensure the final lines are fluid and representative of a trend rather than momentary fluctuations.

Visual Representation (Histogram Modes)

The script offers different ways to display this information on your chart, depending on how you prefer to interpret "strength":

  • Standard View: Shows the smooth values for both bulls and bears clearly so you can see the balance of power.
  • Opposing/Mirrored View: This visually flips one side of the data (making one positive and the other negative), allowing you to see the "tug-of-war" between buyers and sellers as a single continuous wave.
  • Dominance View: The script identifies which side is currently stronger and sets the weaker side to zero. This creates a visual representation of pure dominance, highlighting only the winning side's momentum.
  • Signal View: This isolates the dominant strength into a specific "signal" line, effectively stripping away the losing side's data to show you exactly how much power the leading trend has.

Summary for the Trader

In essence, this tool takes complex price movements and boils them down into a simplified visual of Who is in control? By choosing different modes, you can see whether the market is currently balanced, if one side is overwhelmingly dominant, or how quickly that dominance is shifting over time.

Indicators Used
Moving average indicatorMoving average indicator
Miscellaneous
Implements a curve of type %1
8 Views
0 Downloads
0 Favorites
AbsoluteStrenghtHisto_v1 
//+------------------------------------------------------------------+
//|                                          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    Green
#property indicator_width1    4 
#property indicator_color2    Red
#property indicator_width2    4
#property indicator_color3    Green
#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_002

This indicator quantifies directional dominance by calculating the divergence between bullish and bearish price velocity or range penetration, then applying multi-layered smoothing to visualize net momentum intensity.

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