Ultimate Divergence Detector for Amibroker (AFL)

bkonia

over 10 years ago

Amibroker (AFL)

Divergence is one of the most reliable trading signals, but it’s tricky to identify divergences in real time and if you’re not paying attention, it’s easy to miss a divergence. There are a bunch of divergence detectors posted here, so why another one? Well, I tried all the ones I found and none of them really met my needs, so I decided to create my own. Here’s what makes mine different:

1. Most divergence detectors look for peaks and troughs in price and then try to find a nearby peak or trough in RSI. I took the opposite approach. UDD looks for higher RSI troughs and lower RSI peaks. It then looks for divergences between price and RSI at the current RSI peak/trough, compared with the previous one. I feel this is a more reliable method of identifying divergences, because RSI is less noisy than price. If you want to use a different indicator from RSI, it just involves changing one line of code.

2. UDD plots the RSI and overlays the Zig-Zag indicator on top of it. It then plots a green dot identifying each bullish divergence and a red dot identifying each bearish divergence. This makes it easy for the user to see the divergence. Just follow the Zig-Zag line back to the prior zig/zag point on the graph. The prior point is where the divergence began and the red or green dot is the trade entry point. Peaks or troughs that have no divergence are shown as grey dots.

3. UDD allows the user to specify the RSI length and the percentage change threshold. As you adjust these values, the graph dynamically updates, so you can see the effect of the change in real time. The default RSI length of 14 and percentage threshold of 10% may be too noisy for many markets. If you see too many false signals on the graph, just increase these values until you’re comfortable with how the graph looks.

4. UDD uses pure array processing, no loops, so it’s extremely fast and the code is compact and easy to understand.

5. UDD includes a simple trading system with backtesting. The system buys on each bullish divergence and goes short on each bearish divergence. It exits the trade at the next point on the zig-zag line. For instance, if it goes short on a bearish divergence, it will exit the trade at the next trough. The actual entries and exits occur one bar after the peak or trough is identified. If you backtest this against a variety of markets, you may be surprised at how profitable it is.

Screenshots

Indicator / Formula

// ********************************************
// INDICATOR	: Ultimate Divergence Detector
// DATE			: 07-04-2014
// PROGRAMMER	: Brad Konia
// COPYRIGHTS	: Public Domain
// ********************************************

indName = "RSI"; // Specify the name of the indicator. This is cosmetic only.
length = Param(indName + " Length", 14, 8, 100, 1); // Indicator length
threshold = Param("Zig/Zag Threshold %", 10, 1, 50, 1); // Minimum % change in indicator value to be considered a zig/zag
indVal = RSI(length); // Load the indVal array with the values from the indicator of your choice
indZig = Zig(indVal, threshold); // Set the zig/zag values for the indicator
indPeakVal1 = Peak(indVal, threshold, 1); // Most recent peak value
indPeakBars1 = PeakBars(indVal, threshold, 1); // Bars since most recent peak
indPeakVal2 = Peak(indVal, threshold, 2); // Second most recent peak value
indPeakBars2 = PeakBars(indVal, threshold, 2); // Bars since second most recent peak
indTroughVal1 = Trough(indVal, threshold, 1); // Most recent trough value
indTroughBars1 = TroughBars(indVal, threshold, 1); // Bars since most recent trough
indTroughVal2 = Trough(indVal, threshold, 2); // Second most recent trough value
indTroughBars2 = TroughBars(indVal, threshold, 2); // Bars since second most recent trough

// Determine if current bar is a peak or trough
peakBar = indPeakBars1 == 0;
troughBar = indTroughBars1 == 0;

// Bearish divergence
divergeBear = IIf(peakBar AND (indPeakVal1 < indPeakVal2) AND  High > Ref(High, -indPeakBars2), True, False);
Short = Ref(divergeBear, -1); // Enter short if the previous bar was a bearish divergence
Cover = Ref(troughBar, -1); // Cover short if the previous bar was a trough

// Bullish divergence
divergeBull = IIf((indTroughBars1 == 0) AND (indTroughVal1 > indTroughVal2) AND Low < Ref(Low, -indTroughBars2), True, False);
Buy = Ref(divergeBull, -1); // Enter long if the previous bar was a bullish divergence
Sell = Ref(peakBar, -1); // Close long if the previous bar was a peak

Plot(indVal, indName, colorGrey40);
Plot(indZig, "", colorWhite);
PlotShapes(IIf(peakBar OR troughBar, shapeCircle, shapeNone), colorGrey40, 0, indVal, 0);
PlotShapes(IIf(divergeBear, shapeCircle, shapeNone), colorRed, 0, indVal, 0);
PlotShapes(IIf(divergeBull, shapeCircle, shapeNone),  colorBrightGreen, 0, indVal, 0);

19 comments

Leave Comment

Please login here to leave a comment.