DEV Community: HloniTheCoder

Support And Resistance Identification System Using MQL5

HloniTheCoder — Mon, 25 Sep 2023 10:37:46 +0000

Identify Support and Resistance Using Significant High and Low Levels

The Support and Resistance Identification System is used to identify levels of significance using significant high and low levels.

A level of significance is a level in price that can be used to enter or exit positions, or set position stops.

A significant high and low level is identified using the highest and lowest prices within price ranges.

Project Description

Significant highs and lows ae identified using price ranges.
Price ranges are identified using start indexes and end indexes to identify the highest and lowest price between those indexes.

We will be using a total of 100 candles for our identification.
The total values can be changed to suite the needs of the strategy.

Program Description

Resistance levels will be drawn based on high levels and will be drawn Blue.

Support levels will be drawn based on low levels and will be drawn Red.

Code Description

At the top of our file we will include the following code.


#include <IncludeHighLowData/HighLowData.mqh>

#include <IncludeLineObjects/LineSystems.mqh>

HLowHigh MyHighLowData;

#include is used to get the necessary data classes for our high and low identification, and drawing line types.

HLowHigh MyHighLowData we define a high and low data object, this object will be used to get high and low values.

HLowHigh is a class with the necessary methods for our system.
MyHighLowData is an object used to access the class methods.

Within the OnTick function we will add the following code.

void OnTick(){
    MyHighLowData.Add_Array_Data();
}

The Add_Array_Data method is based on the CopyBuffer function.
This method is used to add the array data to the MyHighLowData object.
Without this method we cannot access current data.


double highest_100 = MyHighLowData.High_Value(50,100);

double highest_50 = MyHighLowData.High_Value(20,50);

double highest_20 = MyHighLowData.High_Value(5,20);

Using the High_Value(start, end) method we access the most significant high between the start and end index.

The highest_100 variable stores the high value of the most significant high between the 50 and 100 index.

The highest_50 variable stores the high value of the most significant high between the 20 and 50 index.

The highest_20 variable stores the high value of the most significant high between the 5 and 20 index.

double lowest_100 = MyHighLowData.Low_Value(50,100);

double lowest_50 = MyHighLowData.Low_Value(20,50);

double lowest_20 = MyHighLowData.Low_Value(5,20);

Using the Low_Value(start,end) method we acess the most significant low between the start and end index.

The lowest_100 variable stores the low values of the most significant low between the 50 and 100 index.

The lowest_50 variable stores the low value of the most significant low between the 20 and 50 index.

The lowest_20 variable stores the low value of the most significant low between the 5 and 20 index.


Create_Horizontal_Line("Highest 100", highest_100, clrBlue);
Create_Horizontal_Line("Highest 0", highest_50, clrBlue);
Create_Horizontal_Line("Highest 20", highest_20, clrBlue);

Create_Horizontal_Line("Lowest 100", lowest_100, clrRed);
Create_Horizontal_Line("Lowest 50", lowest_50, clrRed);
Create_Horizontal_Line("Lowest 20", lowest_20, clrRed);

The Create_Hprizontal_Line function will draw a horizontal line at a significant high and low price.

High levels will be identified using a Blue horizontal line.

Low levels will be identified using a Red horizontal line.

Access to the full code:

HloniTheCoder / Support-And-Resistance-Data

Support-And-Resistance-Data

Within this repository we define the Support and Resistance Indicator System.

The Draw Support and Resistance defines a basic implementation of the Support and Resistance System. This system is based on identifying significant highs and lows to identify levels of support and resistance.

View on GitHub

Trend Based Signal System Using MQL5

HloniTheCoder — Fri, 25 Aug 2023 13:12:04 +0000

Identify Bullish and Bearish Signals Using Momentum

The Trend Based Signal System is used to identify levels of significance based on bullish and bearish momentum.
A level of significance is a level in price that can be used to enter or exit positions, or set position stops.

We identify bullish or bearish momentum using the fast and slow moving average indicator.

During moments of bullish momentum, we identify bullish signals.
During moments of bearish momentum, we identify bearish signals.

Project Description

When the fast moving average indicator is above the slow moving average indicator it represents bullish momentum.
When there is bullish momentum, we identify bullish signals.
Bullish Signals are identified using bullish candlestick patterns.

When the fast moving average indicator is below the slow moving average indicator it represents bearish momentum.
When there is bearish momentum, we identify bearish signals.
Bearish Signals are identified using bearish candlestick patterns.

Program Description

Bullish Signals are identified using a blue horizontal line.
Bearish Signals are identified using a red horizontal line.

We will be using Bullish and Bearish Harami and Engulfing Candlestick Patterns.

Code Description

At the top our file we will include the following code.

#include <IncludeTutorial/IndicatorDataClass>

#include <IncludeTutorial/PriceDataClass>

HSMA FastMAData;

HSMA SlowMAData;

HPriceData MyPriceData;

#include is used to get the necessary data classes for indicator types and price data.

HSMA is the Simple Moving Average class used to access our moving average data.

HPriceData is the Price Data Class used to access our price data.

int OnInit()
{
   FastMAData.Create_SMA_Definition(_Symbol, _Period, 50);

   SlowMAData.Create_SMA_Definition(_Symbol, _Period, 200);
}

Within the OnInit function we will create the Moving Average Indicator Definitions.
The Create_SMA_Definition method creates the indicator definition and initializes the indicator averaging period to 50, for the fast ma, and 200, for the slow ma.

Within the OnTick function we will include the following code:

FastMAData.Add_Array_Data();

SlowMAData.Add_Array_Data();

MyPriceData.Add_Price_Data();

The Add_Array_Data method is used to add the indicator data to the indicator array.
This method is based on the CopyBuffer function.

double fast_ma_value = FastMAData.Get_Indicator_Value(1);

double slow_ma_value = SlowMAData.Get_Indicator_Value(1);

Get the most recent fast and slow moving average value.

bool fast_above_slow = fast_ma_value > slow_ma_value;

bool fast_below_slow = fast_ma_value < slow_ma_value;

The conditions required for determining bullish and bearish momentum.

bool bullish_engulfing = MyPriceData.Get_Is_Bullish_Engulfing(1,5);

bool bearish_engulfing = MyPriceData.Get_Is_Bearish_Engulfing(1,5);

bool bullish_harami = MyPriceData.Get_Is_Bullish_Harami(1,5);

bool bearish_harami = MyPriceData.Get_Is_Bearish_Harami(1,5);

Using the MyPriceData object, we will determine the engulfing and harami candlestick type.
We will find whether or not the most recently completed candlestick, indexed at 1, is an engulfing pattern or harami pattern.

bool bullish_signal = fast_above_slow && (bullish_engulfing || bullish_harami);

bool bearish_signal = fast_below_slow && (bearish_engulfing || bearish_harami);

The above code defines the Boolean variables that handle bullish and bearish signals.

Bullish Signals are defined by a bullish candlestick patterns and bullish momentum, defined by the fast and slow moving average.

Bearish Signals are defined by bearish candlestick patterns and bearish momentum, defined by the fast and slow moving average.

close_value = MyPriceData.Get_Close_Value(1);

if(bullish_signal){
   ObjectCreate(0, "Bullish Signal Level", OBJ_HLINE, 0, 0, close_value);
   ObjectSetInteger(0, "Bullish Signal Level", OBJPROP_COLOR, clrBlue);
}


if(bearish_signal){
   ObjectCreate(0, "Bearish Signal Level", OBJ_HLINE, 0, 0, close_value);
   ObjectSetInteger(0, "Bearish Signal Level", OBJPROP_COLOR, clrRed);
}

When we receive a bullish or bearish signal, we will draw a horizontal line to identify the price in which the signal was identified.

Bullish Signals are identified using a blue horizontal line.
Bearish Signals are identified using a red horizontal line.

Access to the full code:

HloniTheCoder / Simple-Moving-Average-Data

Simple Moving Average Based Strategies.

Within this repository we define the Golden Cross Strategy and Trend Based Signal System.

The Golden Cross Strategy is a double moving average based strategy in which bullish momentum is defined by the fast-period moving average crossing above the slow-period moving average, and bearish momentum is defined by the fast-period moving average crossing below the slow-period moving average.

The Trend Based Signal System is based on a fast and slow period moving average, bullish momentum is based on the fast-period moving average moving above the slow-period moving average and bearish momentum is based on it moving below the slow-period moving average.

When we receive a bullish candlestick pattern while price has bullish momentum, a bullish signal is output When we receicve a bearish candlestick pattern while price has bearish momentum, a bearish signal is output.

The Golden Cross Strategy is based on procedural coding in…

View on GitHub

Golden Cross Strategy Using MQL5

HloniTheCoder — Fri, 25 Aug 2023 10:50:53 +0000

Identify Bullish And Bearish Momentum Using The Golden Cross Strategy

The Golden Cross Strategy is a technical analysis based trading strategy that involves two moving average indicators.

Project Description

This system involves a fast and slow period moving average.
A fast-period moving average is the ma that follows the movement of price closely.
A slow-period moving average is the ma that defines the momentum of price.

When the fast-period ma crosses above the slow-period ma, it defines bullish momentum.
When the fast-period ma crosses below the slow-period ma, it defines bearish momentum.

When a signal for bullish momentum occurs, a vertical line will be drawn to index the date time value.
When we get a signal for bearish momentum we will draw a vertical line to index its occurrence.

Program Description

A blue vertical line will be drawn to define an up cross.
A red vertical line will be drawn to define a down cross.

Code Description

The following strategy code should be written within the OnTick() function.
The OnTick function is a function that executes on every price change.

Within the OnTick function, we will initialize the arrays that will store the indicator data.

double fast_ma_array[];

double slow_ma_array[];

ArraySetAsSeries(fast_ma_array, true);

ArraySetAsSeries(slow_ma_array, true);

The ArraySetAsSeries function sets the array index 0 to the latest MA value.
This is a important function for the performance of the strategy.

int fast_ma_indicator = iMA(_Symbol, _Period, 50, 0, MODE_SMA, PRICE_CLOSE);

int slow_ma_indicator = iMA(_Symbol, _Period, 200, 0, MODE_SMA, PRICE_CLOSE);

The above code initializes the variables that store the indicator data.
We initialize the fast and slow moving averages.
The averaging period of the fast ma is 50.
The averaging period of the slow ma is 200.

CopyBuffer(fast_ma_indicator, 0, 0, 10, fast_ma_array);

CopyBuffer(slow_ma_indicator, 0, 0, 10, slow_ma_array);

The CopyBuffer function copies the indicator data to the indicator data array.
We copy data from the index 0 to index 10.
The index 0 represents the candle index that is currently forming.
The index 10 represents the 10th index away from the current candle.

int curr_fast_value = fast_ma_array[1];

int prev_fast_value = slow_ma_array[2];

int curr_slow_value = slow_ma_array[1];

int prev_slow_value = slow_ma_array[2];

We get the most recent moving average values.
Index 1 represents the most recently completed candle.
Index 2 represents the candle before the most recently completed candle.

Index 1 is the candle before our currently forming candle.

bool curr_fast_above_slow = curr_fast_value > curr_slow_value;

bool prev_fast_above_slow = prev_fast_value > prev_slow_value;

Conditions to determine whether the fast moving average is above the slow moving average.
A Boolean variable can only be true or false.

bool up_cross = curr_fast_above_slow && !(prev_fast_above_slow);

bool down_cross = !(curr_fast_above_slow) && prev_fast_above_slow;

Conditions to determine an up or down cross state.

An up cross means the current fast moving average value is greater than the current slow moving average value, and the previous fast moving average value is less than the previous slow moving average value.

An down cross means the current fast moving average value is less than the current slow moving average value, and the previous fast moving average value is greater than the previous slow moving average value.

The ! operator is the not Boolean operator, if a variable is true the not operator changes the value to false, and does the opposite for false.

MqlRates price_data_array[];

ArraySetAsSeries(price_data_array, true);

CopyRates(_Symbol, _Period, 1, 2, price_data_array);

The MqlRates type allows us to access price data within an array.
The CopyRates function copies price data to the price data array.

if(up_cross){
   ObjectCreate(0, "Up Cross Line", OBJ_VLINE, 0, price_data_array[1].time, 0, 0);
   ObjectSetInteger(0, "Up Cross Line", OBJPROP_COLOR, clrBlue);
}

if(down_cross){
   ObjectCreate(0, "Down Cross Line", OBJ_VLINE, 0, price_data_array[1].time, 0, 0);
   ObjectSetInteger(0, "Down Cross Line", OBJPROP_COLOR, clrRed);
}

If the up cross condition is true, we will draw a vertical line at the index in which the cross occured.
If the down cross condition is true, we will draw a vertical line at the index in which it occured.

The line representing an up cross will be colored blue, whereas the down cross line will be colored red.

For access to the full code:

HloniTheCoder / Simple-Moving-Average-Data

Simple Moving Average Based Strategies.

Within this repository we define the Golden Cross Strategy and Trend Based Signal System.

The Golden Cross Strategy is based on procedural coding in…

View on GitHub

Identify Candlestick Patterns Using OOP in MQL5

HloniTheCoder — Fri, 18 Aug 2023 22:33:56 +0000

Identify Candlestick Patterns Using Object Oriented Programming

Identify Marubozu, Hammer, Inverted Hammer, Hanging Man, Shooting Star Candlestick Patterns.

Access To The Full Code At The Bottom Of The File.

Program Description

A vertical line will be displayed when a candle pattern occurs.

Each Candlestick Pattern has a colour to identify it:

Bullish Marubozu are Red.
Bullish Hammers are Blue.
Bullish Inverted Hammers are Green.
Bearish Marubozu are Yellow.
Bearish Hanging Man are Orange.
Bearish Shooting Stars are Purple.

Code Description

//Get Class Data From The PriceDataClass

#include <IncludeTutorial/PriceDataClass.mqh>


//Access Candlestick Methods Using The HPriceData Class

HPriceData MyPriceData;


//Date Time Index Of The Candle Stick Types

datetime bull_maru_index;

datetime bull_hammer_index;

datetime bull_inv_hammer_index;

datetime bear_maru_index;

datetime bear_hang_man_index;

datetime bear_shoot_star_idex;

At the top of our file we add the code above.

We include the IncludeTutorial/PriceDataClass.mqh file.
This file contains the Price Data Classes we will be using.

Include Tutorial folder should be stored within your MQL5 Include folder that is provided when you install MetaTrader 5.

HPriceData is the class we will be using. It has the candlestick methods to identify candle types.

HPriceData MyPriceData; is an instance of the class.
MyPriceData will be used to access the necessary methods.

The following code block should be written within the OnTick() function.

MyPriceData.Add_Price_Data();

int candle_index = 1;

int avr_range = 7;

MyPriceData.Add_Price_Data(); this method adds price data to the price data array that is used within the class.
Without this method you cannot access recent data.

int candle_index = 1; the candle index variable is used to index price data.

int avr_range = 7; the average number of candles that will be used to determine long or short candles.

bool is_bull_maru = MyPriceData.Get_Long_Bullish_Marubozu_Type(candle_index, avr_range);

bool is_hammer = MyPriceData.Get_Long_Hammer_Type(candle_index, avr_range);

bool is_inv_hammer = MyPriceData.Get_Long_Inverted_Hammer_Type(candle_index, avr_range);

bool is_bear_maru = MyPriceData.Get_Long_Bearish_Marubozu_Type(candle_index, avr_range);

bool is_hang = MyPriceData.Get_Long_Hanging_Man_Type(candle_index, avr_range);

bool is_star = MyPriceData.Get_Long_Shooting_Star_Type(candle_index, avr_range);

We initialize the Boolean variables that hold candlestick pattern data.

The values of the variables can either be True or False.
True indicates the indexed candle is a candlestick pattern.

datetime curr_Time = MyPriceData.Get_DateTime_Value(candle_index);

if(is_bull_maru)
  {

   bull_maru_index = curr_Time;

  }

if(is_hammer)
  {

   bull_hammer_index = curr_Time;

  }

if(is_inv_hammer)
  {

   bull_inv_hammer_index = curr_Time;

  }

if(is_bear_maru)
  {

   bear_maru_index = curr_Time;

  }

if(is_hang)
  {

   bear_hang_man_index = curr_Time;

  }

if(is_star)
  {

   bear_shoot_star_idex = curr_Time;

  }

If the candle is a candlestick pattern, we index the time.

This is necessary to draw a vertical line.

ObjectCreate(0, "Bullish Marubozu Index", OBJ_VLINE, 0, bull_maru_index, 0,0);
ObjectSetInteger(0, "Bullish Marubozu Index", OBJPROP_COLOR, clrRed);

ObjectCreate(0, "Bearish Marubozu Index", OBJ_VLINE, 0, bear_maru_index, 0,0);
ObjectSetInteger(0, "Bearish Marubozu Index", OBJPROP_COLOR, clrYellow);

ObjectCreate(0, "Hammer Index", OBJ_VLINE, 0, bull_hammer_index, 0,0);
ObjectSetInteger(0, "Hammer Index", OBJPROP_COLOR, clrBlue);

ObjectCreate(0, "Inverted Hammer Index", OBJ_VLINE, 0, bull_inv_hammer_index, 0,0);
ObjectSetInteger(0, "Inverted Hammer Index", OBJPROP_COLOR, clrGreen);

ObjectCreate(0, "Hanging Man Index", OBJ_VLINE, 0, bear_hang_man_index, 0,0);
ObjectSetInteger(0, "Hanging Man Index", OBJPROP_COLOR, clrOrange);

ObjectCreate(0, "Shooting Star Index", OBJ_VLINE, 0, bear_shoot_star_idex, 0,0);
ObjectSetInteger(0, "Shooting Star Index", OBJPROP_COLOR, clrPurple);

We create a vertical line when we receive a candlestick pattern.
Each candle pattern type has a colour associated with it.

Full Code, Comments Included:

HloniTheCoder / Candle-Stick-Data

Identify Candlestick Patterns Using MQL5

Identify The Marubozu, Hammer, Inverted Hammer, Hanging Man, Shooting Star Candlestick Patterns.

A Vertical Line Will Be Output Corresponding To The Candle Pattern Type.

The IncludeTutorial Folder Has The File That Contains The Price Data Classes.

The Class Based Candle Stick Data File Uses The Classes Contained In The Include Folder.

The Candle Stick Data File Is Independent Of The Price Data Classes.

View on GitHub

Identify Candlestick Patterns Using MQL5

HloniTheCoder — Fri, 18 Aug 2023 18:04:44 +0000

Identify Candlestick Patterns

Identify the Marubozu, Hammer, Inverted Hammer, Hanging Man, Shooting Star Candlestick patterns.

The MQL5 programming language is based on the MetaTrader 5 platform.

Program Description

The program will output a vertical line to identify a given candlestick pattern.

Bullish Marubozu will be identified using a red vertical line.

Bullish Hammer and Inverted Hammer will be identified using a blue and green line respectively.

Bearish Marubozu will be identified with yellow.
Bearish Hanging Man will be identified with orange.
Bearish Shooting Star will be identified with purple.

Code Description

We will begin our project within the onTick function within the MQL editor.

The OnTick() function executes on every price change.
Within this function we will write our program logic.

Within the OnTick() Function we will initialize our price data array.

//Array To Store Price Data
MqlRates price_data_array[];

//Set The Most Recent Item To Index 0
ArraySetAsSeries(price_data_array, true);

//Copy Price Data To The Array
//Starting From 0 To 100 Price Data Items
CopyRates(_Symbol, _Period, 0, 100, price_data_array);

The first line initializes the array we will use to store price data.

MqlRates price_data_array[];

The ArraySetAsSeries function makes it so that index 0 in our price_data_array is the most recent price data.

This is an important function that if not included changes the functionality of the program.

ArraySetAsSeries(price_data_array, true);

The CopyBuffer function copies the price data of the current symbol, on the current timeframe to the price_data_array[].

This allows us to access the date OHLCV data of the current symbol.

CopyBuffer(_Symbol, _Period, 0, 100, price_data_array[]);

We will copy data from index 0 to index 100.
Index 0 is the currently forming candle.
Index 1 is the most recently formed candle.
Index 100 is the 100th candle away from the most recent candle.

int candle_index = 1;

double curr_close_value = price_data_array[candle_index].close;
double curr_open_value = price_data_array[candle_index].open;
double curr_low_value = price_data_array[candle_index].low;
double curr_high_value = price_data_array[candle_index].high;

We will initialize variables to store our OHLC Data of the most recent candle.

int candle_index=1;
This variable stores the index of the candle whose candle pattern type we want.
Index 1 is the most recently completed candlestick.

Next we will begin calculating average candlestick values.
A candlestick will be considered long if it is greater than the average candle size.

int avg_range = 5; //Length Of Average

for(int i=candle_index;i<=avg_range;i++)
     {

      int val_index = i + 1;

      double open_value = price_data_array[val_index].open;

      double high_value = price_data_array[val_index].high;

      double low_value = price_data_array[val_index].low;

      double close_value = price_data_array[val_index].close;

      double body_size = MathAbs(open_value - close_value);

      double upper_size = 0;

      double lower_size = 0;

      //If The Currently Indexed Candle Is Bullish Or Bearish

      if(close_value > open_value)
        {

         upper_size = MathAbs(high_value - close_value);

         lower_size = MathAbs(open_value - low_value);

        }

      else
        {

         upper_size = MathAbs(high_value - open_value);

         lower_size = MathAbs(close_value - low_value);

        }

      avg_body_sum_value += body_size;

      avg_upper_sum_value += upper_size;

      avg_lower_sum_value += lower_size;

     }


   //Average Body, Upper, and Lower Wick Size Values

   double avg_body_size = avg_body_sum_value / avg_range;

   double avg_upper_size = avg_upper_sum_value / avg_range;

   double avg_lower_size = avg_lower_sum_value / avg_range;

In this code block we are calculating the average body size value, average upper wick size, and average lower wick size.

The Body Size is calculated by subtracting the candle open value with the candle close value.

The Upper Size is calculated by subtracting the candle high from the candle close if bullish, else if bearish we subtract candle high with candle open.

The Lower Size is calculated by subtracting the candle open with the candle low if bullish, else if bearish we subtract candle close with candle low.

The Average Candlestick Data is calculated at an average range of 5 items but this value may be easily changed.

The higher average range value the more candles will be used in the calculation.

Next we will calculate Candlestick Data (Body Size, Upper Wick Size, Lower Wick Size) using the most recent candle values.

double curr_body_size = MathAbs(curr_open_value - curr_close_value);

double curr_upper_size = 0;

double curr_lower_size = 0;

//Determine Whether The Current Candle Is Bullish Or Bearish

bool curr_candle_is_bullish = curr_close_value > curr_open_value;

bool curr_candle_is_bearish = curr_open_value > curr_close_value;


if(curr_candle_is_bullish)
  {

   curr_upper_size = MathAbs(curr_high_value - curr_close_value);

   curr_lower_size = MathAbs(curr_open_value - curr_low_value);

  }

else
  {

   curr_upper_size = MathAbs(curr_high_value - curr_open_value);

   curr_lower_size = MathAbs(curr_close_value - curr_low_value);

  }

In this code block we are calculating the Body Size, Upper Size, and Lower Size for the current candle.

A candle is bullish if the close is greater than the open, and is bearish if the open is greater than the close.

If a candle is bullish, the upper size is the difference between the high value and the close value, the lower size is the difference between the open value and the low value.

If a candle is bearish, the upper size is the difference between the high value and the open value, the lower size is the difference between the close value and the low value.

//Determine Whether The Candlestick Data Is Long Or Short

//Candle Data Is Long If It Is Greater Than 1.5 Times The Input

//The inp_val Will Typically Be The Average Value

bool Calculate_Is_Long(double curr_val, double inp_val){

   bool is_long = (curr_val >= (inp_val * 1.5));

   return(is_long);

}

At the top of our file we will create the Calculate_Is_Long() function, this function is used to determine if a value is long as compared to the average.

We will use the function to Calculate whether the Body Size, Upper Size, Lower Size is Long.

//Determine If The Body, Upper, Lower Wick Are Long

//A Value Is Long If It Is Greater Than The Average Value Times 1.5

bool body_is_long = Calculate_Is_Long(curr_body_size, avg_body_size);

bool upper_is_long = Calculate_Is_Long(curr_upper_size, avg_upper_size);

bool lower_is_long = Calculate_Is_Long(curr_lower_size, avg_lower_size);

Within the OnTick() function we will include the above code script.

We initialize variables that have the values of whether or not the current Body, Upper, or Lower value is Long.

//Calculate The Percentage Value

//Will Be Used To Calculate The Percentage Value Of
//The Body Size, Upper Wick, and Lower Wick Relative To
//The Total Candlestick Size

double Calculate_Percentage_Value(double curr_val, double total_val){

   double div_value = curr_val / total_val;

   double perc_value = div_value * 100;

   return(NormalizeDouble(perc_value, 5));

}


//Determine If Candle Data Is Significant

//If The Body, Upper Wick, or Lower Wick Size Is Significant
//It Means It Occupies Most Of The Candle

bool Calculate_Is_Significant(double perc_value){

   bool is_sig = (perc_value > 70);

   return(is_sig);

}

At the top of our file we will create two more functions.

The Calculate_Percentage_Value() function calculates the percentage value compared to the total value.

We will use this function to calculate the body, upper, and lower wick size compared to the total candle size.

The next function is Calculate_Is_Significant() function which calculates whether candle data occupies most of the candle.

double curr_candle_size = MathAbs(curr_high_value - curr_low_value);

//Calculating The Body, Upper, Lower Wick Percentage Values

//Determining The Percentage Value Of Candle Data Compared To The Candle Size

double curr_body_perc_value = Calculate_Percentage_Value(curr_body_size, curr_candle_size);

double curr_upper_perc_value = Calculate_Percentage_Value(curr_upper_size, curr_candle_size);

double curr_lower_perc_value = Calculate_Percentage_Value(curr_lower_size, curr_candle_size);


//Determine If Candle Data Is Significant

//Body, Upper, Lower Wick Values Are Significant If
//They Occupy Most Of The Candle Size

bool curr_body_is_significant = Calculate_Is_Significant(curr_body_perc_value);

bool curr_upper_is_significant = Calculate_Is_Significant(curr_upper_perc_value);

bool curr_lower_is_significant = Calculate_Is_Significant(curr_lower_perc_value);

Within the OnTick() function we will write the above code.

We will find the percentage value of the body size, upper size, and lower size.

Once we have the percentage values, we will determine whether or not the body size, upper, lower size values are significant in the candle.

//Determine If The Candle Is Of A Type

//If The Body, Upper Wick, or Lower Wick Is Both
//Long And Significant It Is A Type

bool Return_Is_Candle_Type(bool is_long, bool is_sig){

   bool is_type = is_long && is_sig;

   return(is_type);

}


//Date Time Index Of The Candle Stick Types

datetime bull_maru_index;

datetime bull_hammer_index;

datetime bull_inv_hammer_index;

datetime bear_maru_index;

datetime bear_hang_man_index;

datetime bear_shoot_star_idex;

At the top of our file we will add the last functions to determine the candlestick types.

Return_Is_Candle_Type() this function returns whether or not our candle data is a candle type.
A candle type has a long value and the value is significant.

The datetime indexes will be used to find the location of our candlestick pattern types.

//Determine Whether The Body, Upper, Or Lower Wick Are Long Types

//A Long Type Is Both Significant And Long(Greater Than The Average Value)

bool body_is_long_type = Return_Is_Candle_Type(body_is_long, curr_body_is_significant);

bool upper_is_long_type = Return_Is_Candle_Type(upper_is_long, curr_upper_is_significant);

bool lower_is_long_type = Return_Is_Candle_Type(lower_is_long, curr_lower_is_significant);

Within the OnTick() function we initialize variables to contain the values of whether or not our candle values are of the long type.

//Determine Marubozu Type Candles

//Is Bullish Marubozu If The Candle Is Bullish And The Body Is A Long Type
bool is_bull_maru = (curr_candle_is_bullish && body_is_long_type);

//Is Bearish Marubozu If The Candle Is Bearish And The Body Is A Long Type
bool is_bear_maru = (curr_candle_is_bearish && body_is_long_type);


//Determine Hammer And Inverted Hammer Type Candles

//Is Bullish Hammer If The Candle Is Bullish And The Lower Is A Long Type
bool is_bull_hammer = (curr_candle_is_bullish && lower_is_long_type);

//Is Bullish Inverted Hammer If The Candle Is Bullish And The Upper Is A Long Type
bool is_bull_inv_hammer = (curr_candle_is_bullish && upper_is_long_type);


//Determine Hanging Man And Shooting Star Type Candles

//Is Bearish Hanging Man If The Candle Is Bearish And The Lower Is A Long Type
bool is_bear_hang_man = (curr_candle_is_bearish && lower_is_long_type);

//Is Bearish Shooting Star If The Candle Is Bearish And The Upper Is A Long Type
bool is_bear_star = (curr_candle_is_bearish && upper_is_long_type);

The above code block identifies the individual bullish and bearish candle types.

A Bullish Marubozu has a long body type and the body is significant and the candle is bullish.

A Bullish Hammer has a long lower wick type and the lower wick is significant and the candle is bullish.

A Bullish Inverted Hammer has a long upper wick type and the upper wick is significant and the candle is bullish.

A Bearish Marubozu has a long body type, the body is significant, and the candle is bearish.

A Bearish Hanging Man Type has a long lower wick, the lower wick is significant, and the candle is bearish.

A Bearish Shooting Star has a long upper wick, the upper wick is significant, and the candle is bearish.

//Add Candle Type Indexes For Output

if(is_bull_maru)
  {

   bull_maru_index = price_data_array[candle_index].time;

  }

if(is_bull_hammer)
 {

  bull_hammer_index = price_data_array[candle_index].time;

 }

if(is_bull_inv_hammer)
 {

  bull_inv_hammer_index = price_data_array[candle_index].time;

 }

if(is_bear_maru)
 {

 bear_maru_index = price_data_array[candle_index].time;

 }

if(is_bear_hang_man)
 {

 bear_hang_man_index = price_data_array[candle_index].time;

}

if(is_bear_star)
  {

   bear_shoot_star_idex = price_data_array[candle_index].time;

  }

The code above initializes the candlestick pattern types to the datetime indexes of those candle types.

//Output Candle Type Data As A Vertical Line

//The Most Recent Candle Of Each Type Will Be Output

ObjectCreate(0, "Bullish Marubozu Index", OBJ_VLINE, 0, bull_maru_index, 0,0);

ObjectSetInteger(0, "Bullish Marubozu Index", OBJPROP_COLOR, clrRed);


ObjectCreate(0, "Bearish Marubozu Index", OBJ_VLINE, 0, bear_maru_index, 0,0);

ObjectSetInteger(0, "Bearish Marubozu Index", OBJPROP_COLOR, clrYellow);


ObjectCreate(0, "Hammer Index", OBJ_VLINE, 0, bull_hammer_index, 0,0);

ObjectSetInteger(0, "Hammer Index", OBJPROP_COLOR, clrBlue);


ObjectCreate(0, "Inverted Hammer Index", OBJ_VLINE, 0, bull_inv_hammer_index, 0,0);

ObjectSetInteger(0, "Inverted Hammer Index", OBJPROP_COLOR, clrGreen);


ObjectCreate(0, "Hanging Man Index", OBJ_VLINE, 0, bear_hang_man_index, 0,0);

ObjectSetInteger(0, "Hanging Man Index", OBJPROP_COLOR, clrOrange);


ObjectCreate(0, "Shooting Star Index", OBJ_VLINE, 0, bear_shoot_star_idex, 0,0);

ObjectSetInteger(0, "Shooting Star Index", OBJPROP_COLOR, clrPurple);

This final code block is what outputs the vertical lines corresponding to the individual candlestick pattern types.

A link to the full code:

HloniTheCoder / Candle-Stick-Data

Identify Candlestick Patterns Using MQL5

Candlestick Patterns Include Marubozu, Hammer, Inverted Hammer, Hanging Man, Shooting Star

Candlstick Patterns Are Identified Using A Vertical Line Object

The Implementation can be modified to include additional candlestick patterns and methods of output such as arrows, boxes, and text

Red Is Used To Identify Bullish Marubozu

Blue Is Used To Identify Bullish Hammers

Green Is Used To Identify Bullish Inverted Hammers

Yellow Is Used To Identify Bearish Marubozu

Orange Is Used To Identify Bearish Hanging Man

Purple Is Used To Identify Bearish Shooting Star

View on GitHub