FX5_Divergence_v1[1]-1.5

Download script
Author: Copyright � 2007, FX5
FX5_Divergence_v1[1]-1.5

Overview of the FX5 Divergence Indicator

The FX5 Divergence script is a technical analysis tool designed to help traders identify "divergences"—situations where the price action of a financial instrument moves in one direction, while an underlying momentum indicator suggests it is moving in the opposite direction. These discrepancies are often viewed as early warning signs of potential trend reversals.

Core Mechanics and Logic

The logic of this script can be broken down into three primary phases: calculation, identification, and visualization.

1. The Foundation: Oscillator Momentum

Before looking for divergences, the script calculates a custom momentum oscillator based on Moving Averages (EMA). It subtracts a slow-moving average from a fast-moving average to create a base line (MACD style), then further smooths that result into a final signal called OsMA.

This OsMA value acts as the "heartbeat" of the indicator, showing the strength and direction of the current market momentum.

2. Identifying Highs and Lows

To detect a divergence, the script must first find significant "peaks" (high points) and "troughs" (low points) in both the actual price and the momentum oscillator. It scans through historical data to pinpoint specific moments where the momentum shifted direction significantly enough to be considered a peak or a trough.

3. Divergence Detection Logic

The script compares the relationship between two consecutive peaks or troughs. There are four specific types of divergence it tracks:

  • Classic Bearish Divergence: This occurs when the price reaches a higher high than before, but the momentum oscillator reaches a lower high. This suggests that while prices are climbing, the "strength" behind the move is weakening, potentially signaling a coming drop.
  • Reverse Bearish Divergence: This occurs when the price reaches a lower high, but the momentum indicator shows a higher peak. This is a specific variation used to catch unique trend shifts.
  • Classic Bullish Divergence: This happens when the price hits a lower low than before, but the momentum oscillator shows a higher low. This suggests that despite the downward price movement, momentum is shifting upward, potentially signaling a coming rally.
  • Reverse Bullish Divergence: Similar to its bearish counterpart, this identifies cases where the price hits a higher low while the indicator shows a lower trough.

4. Visual Alerts and Reporting

When the script detects any of these conditions, it provides three immediate layers of feedback:

  • Visual Markers: It places specific arrows on the chart (Green for bullish, Red for bearish) to pinpoint exactly where the divergence occurred.
  • Trend Lines: If enabled in the settings, the script automatically draws solid or dotted lines connecting the peaks/troughs on both the price chart and the indicator window. This allows you to visually trace the gap between price movement and momentum.
  • System Alerts: The tool can trigger a pop-up notification on your trading platform, providing an instant alert when a new divergence is confirmed on the current candle.

Summary for the User

Essentially, this script acts as a "truth-checker" for price action. By looking for moments where the market's momentum (OsMA) disagrees with the actual price movement, it helps traders spot potential turning points before they become obvious to the naked eye.

Indicators Used
Moving average indicatorMoving average indicator
Miscellaneous
Implements a curve of type %1It issuies visual alerts to the screen
11 Views
0 Downloads
0 Favorites
FX5_Divergence_v1[1]-1.5 
//+------------------------------------------------------------------+
//|                                               FX5_Divergence.mq4 |
//|                                                              FX5 |
//|                                                    hazem@uk2.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, FX5"
#property link      "hazem@uk2.net"
//----
#property indicator_separate_window
#property indicator_buffers 5
#property indicator_color1 LimeGreen
#property indicator_color2 FireBrick
#property indicator_color3 Green
#property indicator_color4 Red
//---- input parameters
extern string separator1 = "*** OSMA Settings ***";
extern int    fastEMA = 12;
extern int    slowEMA = 26;
extern int    signal = 9;
extern string separator2 = "*** Indicator Settings ***";
extern double positiveSensitivity = 0.0001;
extern double negativeSensitivity = -0.0001;
extern double historyBarsCount = 0;
extern bool   drawDivergenceLines = true;
extern bool   displayAlert = true;
//---- buffers
double upOsMA[];
double downOsMA[];
double bullishDivergence[];
double bearishDivergence[];
double OsMA[];
double MACD[];
double Signal[];
double alertBuffer[];
//----
int chartBarsCount;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   IndicatorBuffers(8);
   
   SetIndexStyle(0, DRAW_HISTOGRAM, STYLE_SOLID, 2);
   SetIndexBuffer(0, upOsMA);
   SetIndexStyle(1, DRAW_HISTOGRAM, STYLE_SOLID, 2);
   SetIndexBuffer(1, downOsMA);
   SetIndexStyle(2, DRAW_ARROW);
   SetIndexBuffer(2, bullishDivergence);
   SetIndexArrow(2, 233);
   SetIndexStyle(3, DRAW_ARROW);
   SetIndexBuffer(3, bearishDivergence);
   SetIndexArrow(3, 234);
   SetIndexStyle(4, DRAW_NONE);
   SetIndexBuffer(4, OsMA);
// additional buffers   
   SetIndexBuffer(5, MACD);
   SetIndexBuffer(6, Signal);
   SetIndexBuffer(7, alertBuffer);      
//----   
   SetIndexDrawBegin(0, signal);
   SetIndexDrawBegin(1, signal);
//----   
   IndicatorDigits(Digits + 2);
   IndicatorShortName("FX5_Divergence(" + fastEMA + "," + slowEMA + "," + signal + ")");
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
   for(int i = ObjectsTotal() - 1; i >= 0; i--)
     {
       string label = ObjectName(i);
       if(StringSubstr(label, 0, 14) != "DivergenceLine")
           continue;
       ObjectDelete(label);   
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   if(historyBarsCount <= 0 || historyBarsCount > Bars)
       chartBarsCount = Bars;
   else
       chartBarsCount = historyBarsCount;
   int countedBars = IndicatorCounted();
   if(countedBars < 0)
       countedBars = 0;
   CalculateOsMA(countedBars);      
   CalculateDivergence(countedBars);   
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CalculateDivergence(int countedBars)
  {
   double arrowSeparation = 1 / MathPow(10, Digits + 2) * 50;
   for(int i = chartBarsCount - countedBars; i >= 0; i--)
     {
       bearishDivergence[i] = EMPTY_VALUE;
       bullishDivergence[i] = EMPTY_VALUE;  
       //----
       int firstPeakOrTroughShift = GetFirstPeakOrTrough(i);
       double firstPeakOrTroughOsMA = OsMA[firstPeakOrTroughShift];
       if(firstPeakOrTroughOsMA > 0)
         {
           int peak_0   = GetIndicatorLastPeak(i);
           int trough_0 = GetIndicatorLastTrough(peak_0);
           int peak_1   = GetIndicatorLastPeak(trough_0);
           int trough_1 = GetIndicatorLastTrough(peak_1);
         }
       else
         {        
           trough_0 = GetIndicatorLastTrough(i);
           peak_0   = GetIndicatorLastPeak(trough_0);
           trough_1 = GetIndicatorLastTrough(peak_0);         
           peak_1   = GetIndicatorLastPeak(trough_1);                       
         }
       if(peak_0 == -1 || peak_1 == -1 || trough_0 == -1 || trough_1 == -1)
           continue;           
       double indicatorLastPeak = OsMA[peak_0];
       double indicatorThePeakBefore = OsMA[peak_1];
       double indicatorLastTrough = OsMA[trough_0];
       double indicatorTheTroughBefore = OsMA[trough_1];
/*      
       int pricePeak_0 = GetPriceLastPeak(peak_0);
       int pricePeak_1 = GetPriceLastPeak(peak_1);
       int priceTrough_0 = GetPriceLastTrough(trough_0);
       int priceTrough_1 = GetPriceLastTrough(trough_1);
*/
       int pricePeak_0 = peak_0;
       int pricePeak_1 = peak_1;
       int priceTrough_0 = trough_0;
       int priceTrough_1 = trough_1;
       //----
       double priceLastPeak = High[pricePeak_0];
       double priceThePeakBefore = High[pricePeak_1];
       double priceLastTrough = Low[priceTrough_0];
       double priceTheTroughBefore = Low[priceTrough_1];
       // Classic bearish divergence condition         
       if(priceLastPeak > priceThePeakBefore && 
          indicatorLastPeak < indicatorThePeakBefore)
         {
           DisplayAlert("Classic bearish divergence on: ", i, pricePeak_0);
           bearishDivergence[peak_0] = upOsMA[peak_0] + arrowSeparation;
           if(drawDivergenceLines)
             {
               PriceDrawLine(Time[pricePeak_0], Time[pricePeak_1], 
                             priceLastPeak, priceThePeakBefore,
                             Red, STYLE_SOLID);
               IndicatorDrawLine(Time[peak_0], Time[peak_1], 
                                 indicatorLastPeak, indicatorThePeakBefore,
                                 Red, STYLE_SOLID);
             }
           continue;
         }
       // Reverse bearsih divergence condition      
       if(priceLastPeak < priceThePeakBefore && indicatorLastPeak > indicatorThePeakBefore)
         {
           DisplayAlert("Reverse bearish divergence on: ", i, pricePeak_0);
           bearishDivergence[peak_0] = upOsMA[peak_0] + arrowSeparation;
           if(drawDivergenceLines)
             {
               PriceDrawLine(Time[pricePeak_0], Time[pricePeak_1], priceLastPeak,
                             priceThePeakBefore, Red, STYLE_DOT);
               IndicatorDrawLine(Time[peak_0], Time[peak_1], indicatorLastPeak,
                                 indicatorThePeakBefore, Red, STYLE_DOT);
             }
           continue;
         }      
       // Classic bullish divergence condition           
       if(priceLastTrough < priceTheTroughBefore && 
          indicatorLastTrough > indicatorTheTroughBefore)
        {
          DisplayAlert("Classic bullish divergence on: ", i, priceTrough_0);
          bullishDivergence[trough_0] = downOsMA[trough_0] - arrowSeparation;
          if(drawDivergenceLines)
            {
              PriceDrawLine(Time[priceTrough_0], Time[priceTrough_1], priceLastTrough,
                            priceTheTroughBefore, Green, STYLE_SOLID);
              IndicatorDrawLine(Time[trough_0], Time[trough_1], indicatorLastTrough,
                                indicatorTheTroughBefore, Green, STYLE_SOLID);
            }
          continue;
        }
       // Hidden bullish divergence condition
       if(priceLastTrough > priceTheTroughBefore && 
          indicatorLastTrough < indicatorTheTroughBefore)
         {
           DisplayAlert("Reverse bullish divergence on: ", i, priceTrough_0);
           bullishDivergence[trough_0] = downOsMA[trough_0] - arrowSeparation;
           if(drawDivergenceLines)
             {
               PriceDrawLine(Time[priceTrough_0], Time[priceTrough_1], priceLastTrough,
                             priceTheTroughBefore, Green, STYLE_DOT);
               IndicatorDrawLine(Time[trough_0], Time[trough_1], indicatorLastTrough,
                                 indicatorTheTroughBefore, Green, STYLE_DOT);
             }
           continue;
         }            
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DisplayAlert(string message, int barIndex, int signalIndex)
  {
    if(displayAlert == true && barIndex == 0 && alertBuffer[signalIndex] != 1)
      {
        Alert(message, Symbol(), " , at:  ", Bid);
        alertBuffer[signalIndex] = 1;
      }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CalculateOsMA(int countedBars)
  {
   for(int i = Bars - countedBars; i >= 0; i--)
     {
       MACD[i]=iMA(NULL, 0, fastEMA, 0, MODE_EMA, PRICE_CLOSE, i) -
               iMA(NULL, 0, slowEMA, 0, MODE_EMA, PRICE_CLOSE, i);
     }
   for(i = Bars - countedBars; i >= 0; i--)
     {
       Signal[i]=iMAOnArray(MACD, Bars, signal, 0, MODE_SMA, i);
       OsMA[i] = MACD[i] - Signal[i];
       //----
       if (OsMA[i] > 0)
         {
           upOsMA[i] = OsMA[i];
           downOsMA[i] = 0;
         }
       else 
           if(OsMA[i] < 0)
             {
               downOsMA[i] = OsMA[i];
               upOsMA[i] = 0;   
             }
           else
             {
               upOsMA[i] = 0;
               downOsMA[i] = 0;   
             }
     }            
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int GetPositiveRegionStart(int index)
  {
    int regionStart;
    for(int i = index + 1; i < Bars; i++)
      {
        if(OsMA[i] >= OsMA[i-1] && OsMA[i] >= OsMA[i+1] && 
           OsMA[i] >= OsMA[i+2] && OsMA[i] > positiveSensitivity)
            return(i);    
      }
    return(-1);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int GetNegativeRegionStart(int index)
  {
    for(int i = index + 1; i < Bars; i++)
      {
        if(OsMA[i] <= OsMA[i-1] && OsMA[i] <= OsMA[i+1] && 
           OsMA[i] <= OsMA[i+2] && OsMA[i] < negativeSensitivity)
            return(i);   
      }
    return(-1);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int GetFirstPeakOrTrough(int index)
  {
   for(int i = index + 1; i < Bars; i++)
     {
       if ((OsMA[i] >= OsMA[i-1] && OsMA[i] >= OsMA[i+1] && 
           OsMA[i] >= OsMA[i+2] && OsMA[i] > positiveSensitivity) ||
           (OsMA[i] <= OsMA[i-1] && OsMA[i] <= OsMA[i+1] && 
           OsMA[i] <= OsMA[i+2] && OsMA[i] < negativeSensitivity))
           return(i);
     }
   return(-1);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int GetIndicatorLastPeak(int index)
  {
   int regionStart = GetPositiveRegionStart(index);
//----
   if(regionStart == -1)
       return(-1); 
   int peakShift = 0;
   double peakValue = 0;
//----
   for(int i = regionStart; i < Bars; i++)
     {
       if(OsMA[i] > peakValue && OsMA[i] >= OsMA[i-1] && 
          OsMA[i] >= OsMA[i+1] && OsMA[i] >= OsMA[i+2] && 
          OsMA[i] > positiveSensitivity)
         {
           peakValue = OsMA[i];
           peakShift = i;
         }
       if(OsMA[i] < 0)
           break;  
     } 
   return(peakShift);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int GetIndicatorLastTrough(int index)
  {
   int regionStart = GetNegativeRegionStart(index);
//----
   if(regionStart == -1)
       return(-1);   
   int troughShift = 0;
   double troughValue = 0;
//----
   for(int i = regionStart; i < Bars; i++)
     {
      if(OsMA[i] < troughValue && OsMA[i] <= OsMA[i-1] && 
         OsMA[i] <= OsMA[i+1] && OsMA[i] <= OsMA[i+2] && 
         OsMA[i] < negativeSensitivity)
        {
          troughValue = OsMA[i];
          troughShift = i;
        }   
      if(OsMA[i] > 0)
          break;  
     }  
   return(troughShift);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PriceDrawLine(datetime x1, datetime x2, double y1, double y2, 
                   color lineColor, double style)
  {
   string label = "DivergenceLine# " + DoubleToStr(x1, 0);
   ObjectDelete(label);
   ObjectCreate(label, OBJ_TREND, 0, x1, y1, x2, y2, 0, 0);
   ObjectSet(label, OBJPROP_RAY, 0);
   ObjectSet(label, OBJPROP_COLOR, lineColor);
   ObjectSet(label, OBJPROP_STYLE, style);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void IndicatorDrawLine(datetime x1, datetime x2, double y1, double y2, 
                       color lineColor, double style)
  {
   int indicatorWindow = WindowFind("FX5_Divergence(" + fastEMA + "," + 
                                    slowEMA + "," + signal + ")");
   if(indicatorWindow < 0)
       return;
   string label = "DivergenceLine$# " + DoubleToStr(x1, 0);
   ObjectDelete(label);
   ObjectCreate(label, OBJ_TREND, indicatorWindow, x1, y1, x2, y2, 0, 0);
   ObjectSet(label, OBJPROP_RAY, 0);
   ObjectSet(label, OBJPROP_COLOR, lineColor);
   ObjectSet(label, OBJPROP_STYLE, style);
  }
//+------------------------------------------------------------------+

Similar scripts

FX5_Divergence_v1.5[1]

This indicator identifies momentum shifts by detecting discrepancies between price action extremes and the Oscillating Moving Average (OsMA) values to highlight classic, hidden, and reverse divergence patterns.

Cloq_v2

AutoKdj

ExportIndicatorwsValues_v2

Williams_Accumulation_Distribution

This indicator quantifies the cumulative net flow of capital by calculating price discrepancies between current and previous closing values relative to historical price boundaries.

SnapShotI

Automates the periodic generation of visual chart archives based on defined temporal intervals and bar-completion triggers.

RAVI_v1

This indicator quantifies the percentage deviation between two Simple Moving Averages of different timeframes to identify trend momentum and price strength.

DayBorders

This script dynamically visualizes the previous calendar day's opening and closing price levels alongside vertical time markers to delineate historical trading boundaries.

DMI_Difference

Candle_Direction

This indicator visualizes real-time price action polarity across nine distinct timeframes by comparing current candle closing prices against their respective opening values.

_MTF_Supertrend_On_Price_v1

Comments