AbsoluteStrenghtHisto_v1_v2

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

Overview of the AbsoluteStrength Logic

The AbsoluteStrength indicator is designed to measure and visualize the underlying momentum of a market by distinguishing between "Bullish" (buying) pressure and "Bearish" (selling) pressure. Instead of simply looking at price movement, it attempts to quantify how much of that movement is driven by each side of the market.

Core Calculation Logic

The script offers two distinct methods for determining how it calculates this strength:

  • Method 1 (RSI Style): This focuses on the rate of change between consecutive price points. It looks at the difference in price from one candle to the next and separates that difference into positive and negative components to see which side is "winning."
  • Method 2 (Stochastic Style): This method compares the current price against the highest highs and lowest lows over a specific period. By doing this, it calculates how far the current price has moved from the extreme boundaries of recent trading activity.

Data Processing and Smoothing

Once the raw Bullish and Bearish values are identified using one of the methods above, the script performs several layers of mathematical refinement to ensure the data is readable and not "noisy":

  1. Averaging: The raw data is smoothed out using a Moving Average. This helps eliminate erratic price spikes that might provide false signals.
  2. Secondary Smoothing: A second smoothing pass is applied to the averaged data. This creates a more fluid, stable visual representation of the market trend.
  3. Signal Generation: The script then calculates specific "Signal Lines" based on these smoothed averages, which represent the momentum's trajectory over time.

Visual Representation (Histogram Modes)

The tool provides different ways to display this information on your chart, depending on your visual preference:

  • Dynamic Switching: The script can automatically swap between histogram and line styles depending on which side (Bullish or Bearish) is currently dominant in the market.
  • Mirroring: It can be configured to flip the values visually, allowing you to see the strength of both sides relative to a center zero-line.
  • Dominance Filtering: In certain modes, the script filters out the weaker side entirely, showing only the "winning" momentum as a histogram while keeping the signal lines visible for context.

Summary for the User

In essence, this script acts as a momentum filter. It takes raw market price data, separates it into buying and selling forces, smooths out the turbulence of the market, and presents you with a clear visual of which side is currently exerting more "absolute strength." This allows traders to see not just where the price is going, but the intensity behind the move.

Indicators Used
Moving average indicatorMoving average indicator
Miscellaneous
Implements a curve of type %1
10 Views
0 Downloads
0 Favorites
AbsoluteStrenghtHisto_v1_v2 
//+------------------------------------------------------------------+
//|                                          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    2 
#property indicator_color2    Red
#property indicator_width2    2
#property indicator_color3    Blue
#property indicator_width3    2 
#property indicator_color4    Magenta
#property indicator_width4    2

//---- input parameters
extern int       Mode   =  0; // 0-RSI method; 1-Stoch method
extern int       Length =  7; // Period
extern int       Smooth =  7; // 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 =  1; // 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,2);
   SetIndexBuffer(0,SmthBulls);
   SetIndexStyle(1,DRAW_HISTOGRAM,EMPTY,2);
   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

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