AdaptiveCyberCycle
Download script
This tool, the Adaptive Cyber Cycle, is a sophisticated technical analysis indicator designed to identify and visualize repeating patterns in financial markets. Based on the principles of cybernetics—the study of communication and automatic control systems—it aims to filter out market "noise" to reveal the underlying rhythmic cycles of price action.
Core Logic and Functionality
The script operates by analyzing historical price data to determine how frequently a market cycle repeats itself. Rather than using a fixed timeframe (which can often mislead traders when market conditions change), this tool is "adaptive," meaning it attempts to adjust its calculations based on the current environment.
Here is a breakdown of the logic used to generate the visual data:
1. Price Smoothing To ensure the indicator doesn't react erratically to minor, momentary price fluctuations, the script first calculates a "smoothed" average of the market price. It looks at the midpoint between the highest and lowest prices over several consecutive bars, blending them together to create a cleaner path for analysis.
2. Dynamic Period Detection The indicator utilizes a secondary calculation (the CyclePeriod) to determine the dominant cycle length at any given moment. By calculating this period dynamically, the tool can distinguish between fast-moving short-term trends and slow-moving long-term cycles.
3. The Adaptive Calculation Once the cycle length is identified, the script applies a specific mathematical formula to calculate the "Cycle" line. This involves:
- Comparing the current smoothed price against previous values.
- Weighting those values based on the detected cycle period.
- Applying an "alpha" factor (a sensitivity setting) that dictates how quickly the indicator reacts to new information versus historical data.
4. The Trigger Mechanism The script produces two primary visual outputs:
- The Cycle Line: This represents the core rhythmic movement of the market, showing where the price is currently positioned within its cycle.
- The Trigger Line: This acts as a delayed reference point (the previous cycle value). By comparing the current Cycle line against this Trigger line, traders can identify shifts in momentum or potential turning points in the market trend.
Summary for Traders
In simple terms, this indicator acts like a sophisticated filter. It takes the chaotic movement of price, smooths out the distractions, identifies the "heartbeat" (cycle) of the market, and projects it onto your screen. By watching the relationship between the Cycle and the Trigger lines, you can better visualize whether the market is currently in an expansionary phase or a contractionary phase.
//+------------------------------------------------------------------+
//| AdaptiveCyberCycle.mq4 |
//| |
//| Adaptive Cyber Cycle |
//| |
//| Algorithm taken from book |
//| "Cybernetics Analysis for Stock and Futures" |
//| by John F. Ehlers |
//| |
//| contact@mqlsoft.com |
//| http://www.mqlsoft.com/ |
//+------------------------------------------------------------------+
#property copyright "Coded by Witold Wozniak"
#property link "www.mqlsoft.com"
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_color1 Red
#property indicator_color2 Blue
#property indicator_level1 0
double Cycle[];
double Trigger[];
double Smooth[];
extern double Alpha = 0.07;
int buffers = 0;
int drawBegin = 0;
int init() {
drawBegin = 8;
initBuffer(Cycle, "Cycle", DRAW_LINE);
initBuffer(Trigger, "Trigger", DRAW_LINE);
initBuffer(Smooth);
IndicatorBuffers(buffers);
IndicatorShortName("Adaptive Cyber Cycle [" + DoubleToStr(Alpha, 2) + "]");
return (0);
}
int start() {
if (Bars <= drawBegin) return (0);
int countedBars = IndicatorCounted();
if (countedBars < 0) return (-1);
if (countedBars > 0) countedBars--;
int s, limit = Bars - countedBars - 1;
for (s = limit; s >= 0; s--) {
Smooth[s] = (P(s) + 2.0 * P(s + 1) + 2.0 * P(s + 2) + P(s + 3)) / 6.0;
double period = iCustom(0, 0, "CyclePeriod", Alpha, 0, s);
double alpha1 = 2.0 / (period + 1.0);
Cycle[s] = (1.0 - 0.5 * alpha1) * (1.0 - 0.5 * alpha1) * (Smooth[s] - 2.0 * Smooth[s + 1]
+ Smooth[s + 2]) + 2.0 * (1.0 - alpha1) * Cycle[s + 1] - (1.0 - alpha1) * Cycle[s + 2];
if (s > Bars - 8) {
Cycle[s] = (P(s) - 2.0 * P(s + 1) + P(s + 2)) / 4.0;
}
Trigger[s] = Cycle[s + 1];
}
return (0);
}
double P(int index) {
return ((High[index] + Low[index]) / 2.0);
}
void initBuffer(double array[], string label = "", int type = DRAW_NONE, int arrow = 0, int style = EMPTY, int width = EMPTY, color clr = CLR_NONE) {
SetIndexBuffer(buffers, array);
SetIndexLabel(buffers, label);
SetIndexEmptyValue(buffers, EMPTY_VALUE);
SetIndexDrawBegin(buffers, drawBegin);
SetIndexShift(buffers, 0);
SetIndexStyle(buffers, type, style, width);
SetIndexArrow(buffers, arrow);
buffers++;
}
Comments