How to solve Fractals over N-bars period in MQL4, similar to IQOptions Fractals indicator? - fractals

Question

I am learning MQL4 myself. I registered with IQOptions for binary options trading.
I am planning to write some indicators myself for my trading system. I like fractals a lot, not from MQL4-supported fractal logic, but very keen on IQOptions specific one.
In MQL4, to find the fractal we use iFractal() which doesn't take any parameters other than an offset.
I convinced myself it just finds fractal over 3 bars. Doing a lot of homework, I have realized that IQOptions indicator is doing more than fractal. Please find the attached screenshot.
I wrote many programs to which I added a recent one below. I need some help to figure out what it has been there. The image I attached is from IQOption screenshot, with fractals over 20 bar period.
//+------------------------------------------------------------------+
//| Bulls.mq4 |
//| Copyright 2005-2014, MetaQuotes Software Corp. |
//| http://www.mql4.com |
//+------------------------------------------------------------------+
#property copyright "2005-2014, MetaQuotes Software Corp."
#property link "http://www.mql4.com"
#property description "Fractals Tanya"
#property strict
//--- indicator settings
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Red
#property indicator_color2 Green
#property indicator_width1 1
#property indicator_width2 1
#property indicator_style1 STYLE_SOLID
#property indicator_style2 STYLE_SOLID
//--- input parameter
input int B_F=20;
//extern int AllB=240;
//--- buffers
double ExtFractalsUPBuffer[];
double ExtFractalsDownBuffer[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
void OnInit(void)
{
//--- 1 additional buffer used for counting.
IndicatorBuffers(2);
IndicatorDigits(Digits);
//--- indicator line
SetIndexBuffer( 0, ExtFractalsUPBuffer );
SetIndexStyle( 0, DRAW_ARROW );
SetIndexArrow( 0, 234 );
SetIndexLabel( 0, NULL );
SetIndexEmptyValue( 0, 0.0 );
SetIndexBuffer( 1, ExtFractalsDownBuffer );
SetIndexStyle( 1, DRAW_ARROW );
SetIndexArrow( 1, 233 );
SetIndexLabel( 1, NULL );
SetIndexEmptyValue( 1, 0.0 );
SetIndexDrawBegin(0,B_F);
SetIndexDrawBegin(1,B_F);
IndicatorShortName( "FractalsTanya" );
IndicatorDigits( Digits );
}
//+------------------------------------------------------------------+
//| Bulls Power |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
int limit=rates_total-prev_calculated;
//---
if(rates_total<=B_F || B_F<=0)
return(0);
//---
if(prev_calculated>0)
limit++;
int i=0,j=0,k=0;
double upFratal=0.0;
double downFratal=0.0;
int x=0; int y=0;
for(int t=0; t<limit+B_F; t++)
{
double upTempFractal=iFractals(NULL,Period(),MODE_UPPER,t);
double downTempFractal=iFractals(NULL,Period(),MODE_LOWER,t);
if(upTempFractal!=0&&upTempFractal>upFratal)
{
upFratal=upTempFractal;
j=t;
}
if(downTempFractal!=0.0&&downFratal==0.0)
{
downFratal=downTempFractal;
}
if(downTempFractal!=0.0&&downTempFractal<=downFratal)
{
downFratal=downTempFractal;
k=t;
}
i++;
if(i==B_F)
{
if(upFratal!=0.0)
{
if(x==0||(j-x)>=B_F)
{
x=j;
ExtFractalsUPBuffer[j]=upFratal;
}
}
if(downFratal!=0.0)
{
if(y==0||(k-y)>=B_F)
{
y=k;
ExtFractalsDownBuffer[k]=downFratal;
}
}
i=0;
upFratal=0.0;
downFratal=0.0;
}
}
/*for(int t=0; t<limit; t++)
{
double upFratal=iFractals(NULL,Period(),MODE_UPPER,t);
double downFratal=iFractals(NULL,Period(),MODE_LOWER,t);
if(upFratal!=0.0)ExtFractalsUPBuffer[t]=upFratal;
else if(downFratal!=0.0)ExtFractalsDownBuffer[t]=downFratal;
}*/
return(rates_total);
}

Answer 1

I took the poster's code and changed it so that it will always give you the value of the last known up- and down fractal, no matter in which bar you're evaluating fractals. I imagine this could be very useful for anyone who reads this who needs this value at any given time.
#property copyright "2021, EA Builder Pro"
#property link "https://www.eabuilderpro.com"
#property description "Fractals always showing most recent value"
#property strict
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Red
#property indicator_color2 Green
#property indicator_width1 1
#property indicator_width2 1
#property indicator_style1 STYLE_SOLID
#property indicator_style2 STYLE_SOLID
input int NumberOfBars=3;
double ExtFractalsUPBuffer[];
double ExtFractalsDownBuffer[];
void OnInit(void)
{
IndicatorBuffers(2);
IndicatorDigits(Digits);
SetIndexBuffer( 0, ExtFractalsUPBuffer );
SetIndexStyle( 0, DRAW_ARROW );
SetIndexArrow( 0, 234 );
SetIndexLabel( 0, "Up" );
SetIndexEmptyValue( 0, 0.0 );
SetIndexBuffer( 1, ExtFractalsDownBuffer );
SetIndexStyle( 1, DRAW_ARROW );
SetIndexArrow( 1, 233 );
SetIndexLabel( 1, "Down" );
SetIndexEmptyValue( 1, 0.0 );
SetIndexDrawBegin(0,NumberOfBars);
SetIndexDrawBegin(1,NumberOfBars);
IndicatorShortName( "FractalsEABuilderPro" );
IndicatorDigits( Digits );
}
//+------------------------------------------------------------------+
//| Bulls Power |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime &time[],
const double &open[],
const double &high[],
const double &low[],
const double &close[],
const long &tick_volume[],
const long &volume[],
const int &spread[])
{
int limit=rates_total-prev_calculated;
if (rates_total <= NumberOfBars || NumberOfBars <= 0)
return(0);
if (prev_calculated > 0)
limit++;
int i = 0, j = 0, k = 0;
double upFractal = 0.0;
double downFractal = 0.0;
int x = 0; int y = 0;
double mostRecentUpTempFractal = 0;
double mostReceptDownTempFractal = 0;
int lastUpPosition = 0;
int lastDownPosition = 0;
for (int b = 100 - NumberOfBars; b >= 0; b--)
{
double upTempFractal = iFractals(NULL,Period(),MODE_UPPER, b);
double downTempFractal = iFractals(NULL,Period(),MODE_LOWER, b);
if (upTempFractal != 0 && upTempFractal > upFractal)
{
upFractal = upTempFractal;
j = b;
}
if (downTempFractal != 0.0 && downFractal == 0.0)
{
downFractal = downTempFractal;
}
if (downTempFractal != 0.0 && downTempFractal <= downFractal)
{
downFractal = downTempFractal;
k = b;
}
i++;
bool upValueSet = false;
bool downValueSet = false;
if (i == NumberOfBars)
{
if (upFractal != 0.0)
{
lastUpPosition = j;
if (x == 0||(j-x) <= NumberOfBars)
{
x = j;
ExtFractalsUPBuffer[j] = upFractal;
mostRecentUpTempFractal = upFractal;
upValueSet = true;
}
}
if (downFractal != 0.0)
{
lastDownPosition = k;
if(y == 0 || (k - y) <= NumberOfBars)
{
y = k;
ExtFractalsDownBuffer[k] = downFractal;
mostReceptDownTempFractal = downFractal;
downValueSet = true;
}
}
i = 0;
upFractal = 0.0;
downFractal = 0.0;
}
if (!upValueSet && mostRecentUpTempFractal != 0.0)
{
lastUpPosition--;
ExtFractalsUPBuffer[lastUpPosition] = mostRecentUpTempFractal;
}
if (!downValueSet && mostReceptDownTempFractal != 0.0)
{
lastDownPosition--;
ExtFractalsDownBuffer[lastDownPosition] = mostReceptDownTempFractal;
}
}
return(rates_total);
}

Answer 2

I assume that what you want to achieve is to find the fractals in the last X bars.
I had the same issue and in my case what I wanted to do was to find the most recent fractals, both up and down, this is the function I created. I used it to calculate a trailing stop.
Changing the function slightly you can find the highest and lowest fractals.
I hope this helps
// ---------------------------------------------------------------------
bool FractalsUp = False;
bool FractalsDown = False;
double FractalsUpPrice = 0;
double FractalsDownPrice = 0;
// -----------------------------------------------Number of bars to scan
int FractalsLimit = 15;
void FindFractals(){
// ------------------------------------------(re)-Initialization of the variables
FractalsUp = False;
FractalsDown = False;
FractalsUpPrice = 0;
FractalsDownPrice = 0;
/* --------------------------------------A for(){...} loop to scan
the last FractalsLimit
candles, starting from
the oldest and finishing
with the most recent one */
for ( int i = FractalsLimit; i >= 0; i-- ){
// ----------------------------------------------------------------------------
double fu = iFractals( NULL, 0, MODE_UPPER, i );
double fl = iFractals( NULL, 0, MODE_LOWER, i );
/* If there is a POSACK of fractal on the candle
the value will be greater than zero
and equal to the highest or lowest price */
// ---------------------------------------------------------------------------
if ( fu > 0 ){ // If there is an upper fractal
FractalsUpPrice = fu; // store the value and
FractalsUp = True; // set True the FractalsUp variable
FractalsDown = False; // set False on POSACK_UP
}
// ----------------------------------------------------------------------------
if ( fl > 0 ){ // If there is an lower fractal
FractalsDownPrice = fl; // store the value and
FractalsUp = False; // set False on POSACK_LO
FractalsDown = True; // set True the FractalsDown variable
}
// ----------------------------------------------------------------------------
if ( fu > 0 // If the candle has both upper
&& fl > 0 // and lower fractal
){
FractalsUpPrice = fu; // the values are stored
FractalsDownPrice = fl;
FractalsUp = False; // but we do not, on NACK,
FractalsDown = False; // consider it as last fractal
}
}
}