mirror of
https://github.com/softwaredevelop/mql5.git
synced 2026-07-27 20:47:44 +00:00
Toh4iem9
117 lines
5.0 KiB
Plaintext
117 lines
5.0 KiB
Plaintext
//+------------------------------------------------------------------+
|
|
//| HA_Tools.mqh |
|
|
//| A toolkit for Heiken Ashi calculations |
|
|
//| Copyright 2025, xxxxxxxx |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2025, xxxxxxxx"
|
|
#property link ""
|
|
|
|
#include <Object.mqh>
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Class CHA_Calculator. |
|
|
//| Purpose: Encapsulates the logic for calculating Heiken Ashi |
|
|
//| candle values from standard OHLC data. This class |
|
|
//| manages its own data buffers. |
|
|
//+------------------------------------------------------------------+
|
|
class CHA_Calculator : public CObject
|
|
{
|
|
public:
|
|
//--- Public Data Members ---
|
|
// These buffers store the calculated Heiken Ashi values and are
|
|
// publicly accessible for indicators to use in their calculations.
|
|
double ha_open[];
|
|
double ha_high[];
|
|
double ha_low[];
|
|
double ha_close[];
|
|
|
|
public:
|
|
//--- Constructor and Destructor
|
|
CHA_Calculator(void);
|
|
~CHA_Calculator(void);
|
|
|
|
//--- Public Interface
|
|
bool Calculate(const int rates_total,
|
|
const int prev_calculated,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &low[],
|
|
const double &close[]);
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CHA_Calculator::CHA_Calculator(void)
|
|
{
|
|
//--- No specific initialization required in the constructor
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CHA_Calculator::~CHA_Calculator(void)
|
|
{
|
|
//--- No specific deinitialization required in the destructor
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Calculates Heiken Ashi values for the entire history. |
|
|
//| INPUT: rates_total - The total number of bars available. |
|
|
//| prev_calculated - The number of bars calculated previously.|
|
|
//| open[], high[], low[], close[] - Standard price arrays. |
|
|
//| RETURN: true if calculation was successful, false otherwise. |
|
|
//+------------------------------------------------------------------+
|
|
bool CHA_Calculator::Calculate(const int rates_total,
|
|
const int prev_calculated,
|
|
const double &open[],
|
|
const double &high[],
|
|
const double &low[],
|
|
const double &close[])
|
|
{
|
|
//--- Ensure internal buffers are sized correctly
|
|
if(ArrayResize(ha_open, rates_total) < 0 ||
|
|
ArrayResize(ha_high, rates_total) < 0 ||
|
|
ArrayResize(ha_low, rates_total) < 0 ||
|
|
ArrayResize(ha_close, rates_total) < 0)
|
|
{
|
|
Print("CHA_Calculator: Error resizing Heiken Ashi buffers!");
|
|
return false;
|
|
}
|
|
|
|
//--- Determine the starting bar for calculation to optimize performance
|
|
int start_pos = 0;
|
|
if(prev_calculated > 1)
|
|
{
|
|
// On subsequent calls, only calculate new bars
|
|
start_pos = prev_calculated - 1;
|
|
}
|
|
|
|
//--- Calculate the very first HA bar (index 0) on the first run
|
|
if(start_pos == 0)
|
|
{
|
|
ha_open[0] = (open[0] + close[0]) / 2.0;
|
|
ha_close[0] = (open[0] + high[0] + low[0] + close[0]) / 4.0;
|
|
// For the first bar, HA High/Low are the same as the regular High/Low
|
|
ha_high[0] = high[0];
|
|
ha_low[0] = low[0];
|
|
start_pos = 1; // Set the starting position for the main loop to the next bar
|
|
}
|
|
|
|
//--- Main loop to calculate all subsequent HA bars
|
|
for(int i = start_pos; i < rates_total; i++)
|
|
{
|
|
// HA Open is the midpoint of the previous HA bar's body
|
|
ha_open[i] = (ha_open[i-1] + ha_close[i-1]) / 2.0;
|
|
// HA Close is the average price of the current regular bar
|
|
ha_close[i] = (open[i] + high[i] + low[i] + close[i]) / 4.0;
|
|
// HA High is the maximum of the current regular High, HA Open, and HA Close
|
|
ha_high[i] = MathMax(high[i], MathMax(ha_open[i], ha_close[i]));
|
|
// HA Low is the minimum of the current regular Low, HA Open, and HA Close
|
|
ha_low[i] = MathMin(low[i], MathMin(ha_open[i], ha_close[i]));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//+------------------------------------------------------------------+
|