FisherCyberCycle_v1
Download scriptThe Fisher Cyber Cycle is a sophisticated technical analysis tool designed to help traders identify market trends and potential turning points by analyzing cyclical patterns in price action. Based on the principles of cybernetics as outlined in specialized financial literature, this script processes raw market data into a smoothed, visual representation of momentum and cycle flow.
Core Logic Overview
Instead of simply reacting to immediate price changes, this tool seeks to filter out "market noise" to reveal the underlying rhythm of the currency or asset. It achieves this through a multi-stage mathematical process:
1. Price Averaging and Smoothing The script begins by identifying the midpoint of the price action (the average of the high and low prices). It then applies a smoothing calculation to these midpoints. This step is crucial because it prevents erratic, momentary price spikes from distorting the overall trend, providing a cleaner foundation for the subsequent calculations.
2. Cycle Detection Once the data is smoothed, the algorithm calculates a "Cycle." This involves a specialized formula that accounts for historical values to determine where the market currently sits within its recurring wave. It essentially tries to map out the "ebb and flow" of the market movement. By comparing current cycle values against previous ones, the tool can help identify whether the market is gaining momentum or beginning to exhaust its current move.
3. Normalization (Relative Positioning) To make the data easier for a human to read, the script performs a normalization process. It looks back at a specific number of bars (defined by the "Length" parameter) to find the highest and lowest points reached within that window. It then calculates where the current cycle value sits relative to those extremes. This transforms raw fluctuations into a structured scale, making it much easier to see when the market is reaching an "overbought" or "oversold" state relative to its recent history.
4. The Fisher Transformation The final stage of the logic applies a "Fisher Transformation." This is a mathematical technique used to linearize price changes. In practical terms, this helps compress the visual data so that the peaks and valleys are more distinct and clearly defined. It makes it easier for a trader to spot the exact moment a trend shifts from upward to downward (or vice versa).
5. Visual Output: The Fisher CC and Trigger The script produces two primary visual lines on your chart:
- Fisher Cyber Cycle (Red): This represents the primary smoothed trend of the cycle. When this line moves sharply, it indicates a change in market momentum.
- Trigger (Blue): This acts as a secondary reference point, showing the previous value of the Fisher calculation. Traders often look for "crosses" between these two lines—where the current momentum line breaks through the trigger line—as a potential signal that a trend is changing direction.
//+------------------------------------------------------------------+
//| FisherCyberCycle.mq4 |
//| |
//| Fisher Stochastic 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 FisherCC[];
double Trigger[];
double Smooth[];
double Cycle[];
double Value1[];
extern double Alpha = 0.07;
extern int Length = 8;
int buffers = 0;
int drawBegin = 0;
int init() {
drawBegin = Length;
initBuffer(FisherCC, "Fisher Cyber Cycle", DRAW_LINE);
initBuffer(Trigger, "Trigger", DRAW_LINE);
initBuffer(Smooth);
initBuffer(Cycle);
initBuffer(Value1);
IndicatorBuffers(buffers);
IndicatorShortName("Fisher Cyber Cycle [" + DoubleToStr(Alpha, 2) + ", " + Length + "]");
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;
Cycle[s] = (1.0 - 0.5 * Alpha) * (1.0 - 0.5 * Alpha) * (Smooth[s] - 2.0 * Smooth[s + 1] + Smooth[s + 2])
+ 2.0 * (1.0 - Alpha) * Cycle[s + 1]
- (1.0 - Alpha) * (1.0 - Alpha) * Cycle[s + 2];
if (s > Bars - 8) {
Cycle[s] = (P(s) - 2.0 * P(s + 1) + P(s + 2)) / 4.0;
}
double hh = Cycle[s], ll = Cycle[s];
for (int i = 0; i < Length; i++) {
double tmp = Cycle[s + i];
hh = MathMax(hh, tmp);
ll = MathMin(ll, tmp);
}
Value1[s] = 0.0;
if (hh != ll) {
Value1[s] = (Cycle[s] - ll) / (hh - ll);
}
FisherCC[s] = (4.0 * Value1[s] + 3.0 * Value1[s + 1] + 2.0 * Value1[s + 2] + Value1[s + 3]) / 10.0;
FisherCC[s] = 0.5 * MathLog((1.0 + 1.98 * (FisherCC[s] - 0.5)) / (1.0 - 1.98 * (FisherCC[s] - 0.5)));
Trigger[s] = FisherCC[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