AbsoluteStrenghtHisto_v1_v1

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

The AbsoluteStrength indicator is a technical analysis tool designed to measure and visualize the momentum between "bullish" (buying) and "bearish" (selling) forces in a financial market. Rather than just showing price action, it attempts to quantify the underlying strength of each side to help traders identify who is currently in control of the market trend.

Core Calculation Logic

The script operates by separating price movement into two distinct categories:

  • Bullish Strength: The upward momentum or buying pressure.
  • Bearish Strength: The downward momentum or selling pressure.

To achieve this, the tool offers two different mathematical methods (modes) to determine these values:

  1. Relative Movement Method: This looks at the change in price between the current bar and the previous one. It calculates whether the movement was positive or negative and captures the magnitude of that shift.
  2. Range Extremes Method: This measures where the current price sits relative to the highest highs and lowest lows over a specific period. For example, if the price is near the recent high, it suggests strong bullish strength; if it is near the recent low, it suggests bearish strength.

Data Refinement and Smoothing

Raw market data can be "noisy," which often leads to erratic signals. To provide a cleaner view for the trader, the script performs a multi-layered smoothing process:

  • Averaging: It calculates an average of the bullish and bearish strengths over a user-defined period.
  • Smoothing: It applies a second layer of smoothing to these averages. This reduces "jitter" and helps highlight the broader trend rather than momentary price spikes.

Visual Representation (Histogram Modes)

The tool provides several ways to display this data visually, depending on how the user prefers to interpret the market:

  • Standard Comparison: Displays the smoothed bullish and bearish values side-by-side, allowing for a direct comparison of which force is larger at any given moment.
  • Opposing Histogram: This reflects the two forces against each other (often one pointing up and one pointing down). If the "bulls" are stronger, their value is shown positively; if the "bears" are stronger, their value is flipped to show a negative orientation. This creates a "mirror" effect that makes it easy to see which side is dominating.
  • Dominance Tracking: In certain modes, the script simplifies the visual entirely by only showing the strongest force. If buying pressure is higher, it shows the bullish value and hides the bearish; if selling pressure is higher, it shows the bearish value and hides the bullish. This provides a very clean "winner-takes-all" visual of the current market sentiment.

Summary for the User

Essentially, this script acts as a "tug-of-war" meter. It looks at the history of price movements, determines which side is pulling harder (buyers or sellers), smooths out the distractions of minor price fluctuations, and presents that information in a visual format that allows you to see the prevailing market sentiment at a glance.

Indicators Used
Moving average indicatorMoving average indicator
Miscellaneous
Implements a curve of type %1
11 Views
0 Downloads
0 Favorites
AbsoluteStrenghtHisto_v1_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    Blue
#property indicator_width1    3
#property indicator_color2    Red
#property indicator_width2    3
#property indicator_color3    DeepSkyBlue
#property indicator_width3    1
#property indicator_color4    Red
#property indicator_width4    1
//---- 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,3);
   SetIndexBuffer(0,SmthBulls);
   SetIndexStyle(1,DRAW_HISTOGRAM,EMPTY,3);
   SetIndexBuffer(1,SmthBears);
   //
   SetIndexStyle(2,DRAW_LINE,EMPTY,1);
   SetIndexBuffer(2,SigBulls);
   SetIndexStyle(3,DRAW_LINE,EMPTY,1);
   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

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.

AbsoluteStrength TimeFrame

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

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

turtlechanneli

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

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.

KI

This indicator identifies momentum shifts by calculating the moving average of the spread between two exponential averages and triggering signals upon zero-line crossovers.

Comments