saherelm/xMQL5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
963e045e65ffb9687c96209324ea07f76dc29778
xMQL5/BKPS/14041018/Documents/BKP/x-saherelm.xfima.helper.mq5
T
saherelm 963e045e65 last backup ...
2026-01-08 11:39:42 +03:30

4974 lines
114 KiB
Plaintext
Raw Blame History

///////////////////////////////////////////////////////
//
// SaherElm IT Center MQL5 Helper Class Library
// ----------------------------------------------
// Name: XCXFIMAHelper
// Description: provides all Indicator
// Helper requirements ...
//
//
// Maintainer:
// ------------
// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com)
//
//////////////////////////////////////////////////////
//
// Global Properties ...
#property library
#property copyright "Copyright 2023, SaherElm IT Center"
#property link "https://www.saherelm.ir"
#property version "1.00"
#property strict
//
// Imports ...
#include "../Classes/x-saherelm.x-helper.class.mq5"
#include "../Libraries/x-saherelm.x-poi.extensions.lib.mq5"
#include "../Libraries/x-saherelm.x-poi.lib.mq5"
//
// Definitions ...
//
// Buffers ...
enum ENUM_XFIMA_BUFFERS
{
XFIMA_MA_FAST_LINE = 0,
XFIMA_MA_FAST_COLOR_LINE = 1,
XFIMA_MA_FAST_STATE_LINE = 19,
XFIMA_MA_SLOW_LINE = 2,
XFIMA_MA_SLOW_COLOR_LINE = 3,
XFIMA_MA_SLOW_STATE_LINE = 20,
XFIMA_SAR_LINE = 4,
XFIMA_SAR_COLOR_LINE = 5,
XFIMA_SAR_STATE_LINE = 21,
XFIMA_PEAK_LINE = 6,
XFIMA_VALE_LINE = 7,
XFIMA_FIBO_UPPER_LINE = 8,
XFIMA_FIBO_MIDDLE_LINE = 9,
XFIMA_FIBO_LOWER_LINE = 10,
XFIMA_ZIGZAG_LINE = 11,
XFIMA_MA_BAND_UPPER_LINE = 12,
XFIMA_MA_BAND_LOWER_LINE = 13,
XFIMA_ZIGZAG_HIGHS_LINE = 30,
XFIMA_ZIGZAG_HIGHS_TIME_LINE = 31,
XFIMA_ZIGZAG_LOWS_LINE = 32,
XFIMA_ZIGZAG_LOWS_TIME_LINE = 33,
//
XFIMA_HK_OPEN_LINE = 14,
XFIMA_HK_HIGH_LINE = 15,
XFIMA_HK_LOW_LINE = 16,
XFIMA_HK_CLOSE_LINE = 17,
XFIMA_HK_COLOR_LINE = 18,
// 19 Ma Fast State
// 20 Ma Slow State
// 21 Sar State
XFIMA_SC_HH_LINE = 22,
XFIMA_SC_LL_LINE = 23,
XFIMA_MC_HH_LINE = 24,
XFIMA_MC_LL_LINE = 25,
XFIMA_LC_HH_LINE = 26,
XFIMA_LC_LL_LINE = 27,
XFIMA_HC_HH_LINE = 28,
XFIMA_HC_LL_LINE = 29,
// 30 ZigZag Highs
// 31 ZigZag Highs Time
// 32 ZigZag Lows
// 33 ZigZag Lows Time
};
//
// Input Models ...
struct XFIMAInputs
{
//
// Props ...
//
// Calculation ...
ENUM_X_PERIOD_METHOD scMethod; // How to Find Short Period
ENUM_TIMEFRAMES scPeriod; // Short Period
ENUM_X_PERIOD_METHOD mcMethod; // How to Find Medium Period
ENUM_TIMEFRAMES mcPeriod; // Medium Period
ENUM_X_PERIOD_METHOD lcMethod; // How to Find Long Period
ENUM_TIMEFRAMES lcPeriod; // Long Period
ENUM_X_PERIOD_METHOD hcMethod; // How to Find Hind Period
ENUM_TIMEFRAMES hcPeriod; // Hind Period
ENUM_SERIESMODE upperMode; // Peak Method
ENUM_SERIESMODE lowerMode; // Vale Method
ENUM_X_FIBO_LEVELS fiboUpperZoneLevel; // Upper Zone Level
ENUM_X_FIBO_LEVELS fiboMiddleZoneLevel; // Upper Zone Level
ENUM_X_FIBO_LEVELS fiboLowerZoneLevel; // Lower Zone Level
double sarStep; // SAR Step
double sarMax; // SAR Maximum
ENUM_MA_METHOD maMethod; // MA Method
ENUM_APPLIED_PRICE maAppliedTo; // MA Applied To
int maFastLength; // Fast MA Length
int maSlowLength; // Slow MA Length
int maBandLength; // MA Band Length
int zigzagDepth; // ZigZag Depth
int zigzagDeviation; // ZigZag Deviation
int zigzagBackStep; // ZigZag Back Step
ENUM_X_PRICE zigzagUppersMode; // ZigZag High Detect Mode
ENUM_X_PRICE zigzagLowersMode; // ZigZag Low Detect Mode
//
// Presentation ...
bool showPV; // Show PV
bool showHK; // Show HK
bool showSAR; // Show Sar
bool showMAFast; // Show MA Fast
bool showMASlow; // Show MA Slow
bool showMABand; // Show MA Band
bool showZigZag; // Show ZigZag
bool showFiboZone; // Show Fibo Zone
int startCalculationForLastBars; // Calculate Last n Bars
int sarArrowCode; // Parabolic Sar Arrow Code
int peakArrowCode; // Peaks Arrow Code
int valeArrowCode; // Vales Arrow Code
//
// Constructor(s) ...
XFIMAInputs()
{
Clean();
}
//
// Tools ...
//
// Clean ...
void Clean()
{
ZeroMemory(this);
}
//
// Default ...
void Default()
{
//
// Calculations ...
scMethod = X_PERIOD_AUTO; // How to Find Short Period
scPeriod = NULL; // Short Period
mcMethod = X_PERIOD_AUTO; // How to Find Medium Period
mcPeriod = NULL; // Medium Period
lcMethod = X_PERIOD_AUTO; // How to Find Long Period
lcPeriod = NULL; // Long Period
hcMethod = X_PERIOD_AUTO; // How to Find Hind Period
hcPeriod = NULL; // Hind Period
upperMode = MODE_HIGH; // Peak Method
lowerMode = MODE_LOW; // Vale Method
fiboUpperZoneLevel = X_FIBO_LEVEL_382; // Upper Zone Level
fiboMiddleZoneLevel = X_FIBO_LEVEL_500; // Upper Zone Level
fiboLowerZoneLevel = X_FIBO_LEVEL_618; // Lower Zone Level
sarStep = 0.02; // SAR Step
sarMax = 0.2; // SAR Maximum
maMethod = MODE_EMA; // MA Method
maAppliedTo = PRICE_CLOSE; // MA Applied To
maFastLength = 7; // Fast MA Length
maSlowLength = 20; // Slow MA Length
maBandLength = 7; // MA Band Length
zigzagDepth = 12; // ZigZag Depth
zigzagDeviation = 5; // ZigZag Deviation
zigzagBackStep = 3; // ZigZag Back Step
zigzagUppersMode = X_PRICE_HIGH; // ZigZag High Detect Mode
zigzagLowersMode = X_PRICE_LOW; // ZigZag Low Detect Mode
//
// Presentation ...
showPV = true; // Show PV
showHK = true; // Show HK
showSAR = true; // Show Sar
showMAFast = true; // Show MA Fast
showMASlow = true; // Show MA Slow
showMABand = true; // Show MA Band
showZigZag = true; // Show ZigZag
showFiboZone = true; // Show Fibo Zone
startCalculationForLastBars = 1500; // Calculate Last n Bars
sarArrowCode = 159; // Parabolic Sar Arrow Code
peakArrowCode = 159; // Peaks Arrow Code
valeArrowCode = 159; // Vales Arrow Code
}
//
// Hide all Visible Buffers ...
void Hide()
{
//
showPV = false;
showHK = false;
showSAR = false;
showMAFast = false;
showMASlow = false;
showMABand = false;
showZigZag = false;
showFiboZone = false;
}
//
// Validate ...
bool IsValid()
{
//
bool result = false;
//
result =
//
// MA ...
maFastLength >= 2 &&
maSlowLength >= 2 &&
maBandLength >= 2 &&
maSlowLength > maFastLength &&
//
// SAR ...
sarMax > 0 &&
sarStep > 0 &&
sarMax > sarStep &&
//
// CYCLES ...
(IsSpecifiedValid(scMethod, scPeriod) &&
IsSpecifiedValid(mcMethod, mcPeriod) &&
IsSpecifiedValid(lcMethod, lcPeriod) &&
IsSpecifiedValid(hcMethod, hcPeriod)) &&
//
// ZIGZAG ...
zigzagDepth > 0 &&
zigzagDeviation > 0 &&
zigzagBackStep > 0 &&
//
// Validate Upper Mode Detection ...
IsXValid(zigzagUppersMode) &&
//
// Validate Lower Mode Detection ...
IsXValid(zigzagLowersMode)
//
;
//
return result;
}
};
//
// Conditions ...
struct XFIMAConditions
{
//
// Common ...
string symbol;
ENUM_TIMEFRAMES period;
datetime time;
//
datetime to;
datetime from;
XOHCL bars[];
//
// Buffers ...
double maFastBuffer[];
double maFastColorBuffer[];
double maFastStateBuffer[];
double maSlowBuffer[];
double maSlowColorBuffer[];
double maSlowStateBuffer[];
double maBandUpperBuffer[];
double maBandLowerBuffer[];
double sarBuffer[];
double sarColorBuffer[];
double sarStateBuffer[];
double peakBuffer[];
double valeBuffer[];
double fiboUpperBuffer[];
double fiboMiddleBuffer[];
double fiboLowerBuffer[];
double zigzagBuffer[];
double sHHBuffer[];
double sLLBuffer[];
double mHHBuffer[];
double mLLBuffer[];
double lHHBuffer[];
double lLLBuffer[];
double hHHBuffer[];
double hLLBuffer[];
double highsBuffer[];
double highsTimeBuffer[];
double lowsBuffer[];
double lowsTimeBuffer[];
double hkOpenBuffer[];
double hkHighBuffer[];
double hkLowBuffer[];
double hkCloseBuffer[];
double hkColorBuffer[];
//
// Conditions ...
//
// Constructor ...
XFIMAConditions()
{
Clean();
}
//
// Tools ...
/**
* Cleaning Up ...
*/
void Clean()
{
//
// Commons ...
to = NULL;
from = NULL;
time = NULL;
symbol = NULL;
period = NULL;
//
// Buffers ...
//
SpecifiedClean(bars);
//
SpecifiedClean(maFastBuffer);
SpecifiedClean(maFastColorBuffer);
SpecifiedClean(maFastStateBuffer);
SpecifiedClean(maSlowBuffer);
SpecifiedClean(maSlowColorBuffer);
SpecifiedClean(maSlowStateBuffer);
SpecifiedClean(maBandUpperBuffer);
SpecifiedClean(maBandLowerBuffer);
SpecifiedClean(sarBuffer);
SpecifiedClean(sarColorBuffer);
SpecifiedClean(sarStateBuffer);
SpecifiedClean(peakBuffer);
SpecifiedClean(valeBuffer);
SpecifiedClean(fiboUpperBuffer);
SpecifiedClean(fiboMiddleBuffer);
SpecifiedClean(fiboLowerBuffer);
SpecifiedClean(zigzagBuffer);
SpecifiedClean(sHHBuffer);
SpecifiedClean(sLLBuffer);
SpecifiedClean(mHHBuffer);
SpecifiedClean(mLLBuffer);
SpecifiedClean(lHHBuffer);
SpecifiedClean(lLLBuffer);
SpecifiedClean(hHHBuffer);
SpecifiedClean(hLLBuffer);
SpecifiedClean(highsBuffer);
SpecifiedClean(highsTimeBuffer);
SpecifiedClean(lowsBuffer);
SpecifiedClean(lowsTimeBuffer);
SpecifiedClean(hkOpenBuffer);
SpecifiedClean(hkHighBuffer);
SpecifiedClean(hkLowBuffer);
SpecifiedClean(hkCloseBuffer);
SpecifiedClean(hkColorBuffer);
//
// Conditions ...
//
ArraySetAsSeries(bars, true);
//
ArraySetAsSeries(maFastBuffer, true);
ArraySetAsSeries(maFastColorBuffer, true);
ArraySetAsSeries(maFastStateBuffer, true);
ArraySetAsSeries(maSlowBuffer, true);
ArraySetAsSeries(maSlowColorBuffer, true);
ArraySetAsSeries(maSlowStateBuffer, true);
ArraySetAsSeries(maBandUpperBuffer, true);
ArraySetAsSeries(maBandLowerBuffer, true);
ArraySetAsSeries(sarBuffer, true);
ArraySetAsSeries(sarColorBuffer, true);
ArraySetAsSeries(sarStateBuffer, true);
ArraySetAsSeries(peakBuffer, true);
ArraySetAsSeries(valeBuffer, true);
ArraySetAsSeries(fiboUpperBuffer, true);
ArraySetAsSeries(fiboMiddleBuffer, true);
ArraySetAsSeries(fiboLowerBuffer, true);
ArraySetAsSeries(zigzagBuffer, false); // Fix this ...
ArraySetAsSeries(sHHBuffer, true);
ArraySetAsSeries(sLLBuffer, true);
ArraySetAsSeries(mHHBuffer, true);
ArraySetAsSeries(mLLBuffer, true);
ArraySetAsSeries(lHHBuffer, true);
ArraySetAsSeries(lLLBuffer, true);
ArraySetAsSeries(hHHBuffer, true);
ArraySetAsSeries(hLLBuffer, true);
ArraySetAsSeries(highsBuffer, true);
ArraySetAsSeries(highsTimeBuffer, true);
ArraySetAsSeries(lowsBuffer, true);
ArraySetAsSeries(lowsTimeBuffer, true);
ArraySetAsSeries(hkOpenBuffer, true);
ArraySetAsSeries(hkHighBuffer, true);
ArraySetAsSeries(hkLowBuffer, true);
ArraySetAsSeries(hkCloseBuffer, true);
ArraySetAsSeries(hkColorBuffer, true);
//
ZeroMemory(this);
}
/**
* Generate Conditions Scores ...
*
* @param bullishScore: Double, Directional Scores Reference ...
* @param bearishScore: Double, Directional Scores Reference ...
*/
void GenerateScore(
double &bullishScore,
double &bearishScore //
)
{
}
/**
* Generate Summary String for Represent Conditions State ...
*
* @param onlyCommons: Boolean, Just Generate Only Commons Conditions ...
* @param onlyConditions: Boolean, Just Generate Only Conditions ...
* @param includeScores: Boolean, Attach Scores Representations on Result ...
* @param ignoreFalseConditions: Boolean, Ignore False Conditions on Result ...
* @param separator: String, Separate Lines ...
*
* @return ( string )
*/
string GenerateSummary(
bool onlyCommons = false,
bool onlyConditions = false,
bool includeScores = true,
bool ignoreFalseConditions = true,
string separator = "\n" //
)
{
return "";
}
/**
* Retrieve Unique Tag Identifier ...
*
* @return ( string )
*/
string GetTag()
{
return GetToken(this);
}
};
//
// Class ...
class XCXFIMAHelper : public XCBaseHelper
{
//
// Public ...
public:
//
// Props ...
//
// Buffers ...
double maFastBuffer[];
double maFastColorBuffer[];
double maFastStateBuffer[];
double maSlowBuffer[];
double maSlowColorBuffer[];
double maSlowStateBuffer[];
double maBandUpperBuffer[];
double maBandLowerBuffer[];
double sarBuffer[];
double sarColorBuffer[];
double sarStateBuffer[];
double peakBuffer[];
double valeBuffer[];
double fiboUpperBuffer[];
double fiboMiddleBuffer[];
double fiboLowerBuffer[];
double zigzagBuffer[];
double sHHBuffer[];
double sLLBuffer[];
double mHHBuffer[];
double mLLBuffer[];
double lHHBuffer[];
double lLLBuffer[];
double hHHBuffer[];
double hLLBuffer[];
double highsBuffer[];
double highsTimeBuffer[];
double lowsBuffer[];
double lowsTimeBuffer[];
double hkOpenBuffer[];
double hkHighBuffer[];
double hkLowBuffer[];
double hkCloseBuffer[];
double hkColorBuffer[];
//
// Constructors ...
XCXFIMAHelper()
: XCBaseHelper(_Symbol, _Period)
{
}
//
// Deconstructor ...
~XCXFIMAHelper()
{
}
//
// Tools ...
//
// Initialize Helper Cleass ...
bool Init(
string symbol, // Trading Symbol
ENUM_TIMEFRAMES period, // Trading Period
XFIMAInputs &inputs // Inputs
)
{
//
bool result = false;
//
mSymbol = symbol;
mPeriod = period;
//
result = inputs.IsValid();
if (!result)
{
return result;
}
//
ArraySetAsSeries(maFastBuffer, true);
ArraySetAsSeries(maFastColorBuffer, true);
ArraySetAsSeries(maFastStateBuffer, true);
ArraySetAsSeries(maSlowBuffer, true);
ArraySetAsSeries(maSlowColorBuffer, true);
ArraySetAsSeries(maSlowStateBuffer, true);
ArraySetAsSeries(maBandUpperBuffer, true);
ArraySetAsSeries(maBandLowerBuffer, true);
ArraySetAsSeries(sarBuffer, true);
ArraySetAsSeries(sarColorBuffer, true);
ArraySetAsSeries(sarStateBuffer, true);
ArraySetAsSeries(peakBuffer, true);
ArraySetAsSeries(valeBuffer, true);
ArraySetAsSeries(fiboUpperBuffer, true);
ArraySetAsSeries(fiboMiddleBuffer, true);
ArraySetAsSeries(fiboLowerBuffer, true);
ArraySetAsSeries(zigzagBuffer, false); // TODO: FIX This ...
ArraySetAsSeries(sHHBuffer, true);
ArraySetAsSeries(sLLBuffer, true);
ArraySetAsSeries(mHHBuffer, true);
ArraySetAsSeries(mLLBuffer, true);
ArraySetAsSeries(lHHBuffer, true);
ArraySetAsSeries(lLLBuffer, true);
ArraySetAsSeries(hHHBuffer, true);
ArraySetAsSeries(hLLBuffer, true);
ArraySetAsSeries(highsBuffer, true);
ArraySetAsSeries(highsTimeBuffer, true);
ArraySetAsSeries(lowsBuffer, true);
ArraySetAsSeries(lowsTimeBuffer, true);
ArraySetAsSeries(hkOpenBuffer, true);
ArraySetAsSeries(hkHighBuffer, true);
ArraySetAsSeries(hkLowBuffer, true);
ArraySetAsSeries(hkCloseBuffer, true);
ArraySetAsSeries(hkColorBuffer, true);
//
mInputs = inputs;
//
mHandler = iCustom(
mSymbol,
mPeriod,
"x-saherelm.xfima",
"", // Calculation ...
mInputs.scMethod,
mInputs.scPeriod,
mInputs.mcMethod,
mInputs.mcPeriod,
mInputs.lcMethod,
mInputs.lcPeriod,
mInputs.hcMethod,
mInputs.hcPeriod,
mInputs.upperMode,
mInputs.lowerMode,
mInputs.fiboUpperZoneLevel,
mInputs.fiboMiddleZoneLevel,
mInputs.fiboLowerZoneLevel,
mInputs.sarStep,
mInputs.sarMax,
mInputs.maMethod,
mInputs.maAppliedTo,
mInputs.maFastLength,
mInputs.maSlowLength,
mInputs.maBandLength,
mInputs.zigzagDepth,
mInputs.zigzagDeviation,
mInputs.zigzagBackStep,
mInputs.zigzagUppersMode,
mInputs.zigzagLowersMode,
"", // Presentation ...
mInputs.showPV,
mInputs.showHK,
mInputs.showSAR,
mInputs.showMAFast,
mInputs.showMASlow,
mInputs.showMABand,
mInputs.showZigZag,
mInputs.showFiboZone,
mInputs.startCalculationForLastBars,
mInputs.sarArrowCode,
mInputs.peakArrowCode,
mInputs.valeArrowCode
//
);
result = mHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
return result;
}
//
// Inputs ...
//
XFIMAInputs GetInputs()
{
return mInputs;
}
//
bool SetInputs(
XFIMAInputs &inputs // Configs
)
{
//
return Init(
mSymbol,
mPeriod,
inputs //
);
}
//
// Tools ...
//
void Update(
int barIndex // Bar Index
)
{
Calculate(barIndex);
}
//
void Free() override
{
Cleanup(10);
}
//
bool GetConditions(
XFIMAConditions &conditions, //
int barIndex = 0, //
int loopback = 5 //
)
{
//
bool result = true;
//
if (loopback < 5)
{
loopback = 5;
}
//
conditions.Clean();
//
conditions.symbol = mSymbol;
conditions.period = mPeriod;
conditions.time = TimeCurrent();
//
// Filling Bars ...
int barsCount = GetBars(
conditions.bars,
mSymbol,
mPeriod,
barIndex,
loopback //
);
result = barsCount == loopback;
if (!result)
{
//
conditions.Clean();
//
return result;
}
//
int zIDX = 0;
int cIDX = 1;
int pIDX = cIDX + 1;
int p2IDX = pIDX + 1;
int p3IDX = p2IDX + 1;
int p4IDX = p3IDX + 1;
//
conditions.to = conditions.bars[0].time;
conditions.from = conditions.bars[ArraySize(conditions.bars) - 1].time;
//
int zIndex = barIndex;
//
// Buffers ...
//
CopyMAFast(
zIndex,
loopback,
conditions.maFastBuffer //
);
//
CopyMAFastState(
zIndex,
loopback,
conditions.maFastStateBuffer //
);
//
CopyMASlow(
zIndex,
loopback,
conditions.maSlowBuffer //
);
//
CopyMASlowState(
zIndex,
loopback,
conditions.maSlowStateBuffer //
);
//
CopyMABandUpper(
zIndex,
loopback,
conditions.maBandUpperBuffer //
);
//
CopyMABandLower(
zIndex,
loopback,
conditions.maBandLowerBuffer //
);
//
CopySar(
zIndex,
loopback,
conditions.sarBuffer //
);
//
CopySarState(
zIndex,
loopback,
conditions.sarStateBuffer //
);
//
CopyPeak(
zIndex,
loopback,
conditions.peakBuffer //
);
//
CopyVale(
zIndex,
loopback,
conditions.valeBuffer //
);
//
CopyFiboUpper(
zIndex,
loopback,
conditions.fiboUpperBuffer //
);
//
CopyFiboMiddle(
zIndex,
loopback,
conditions.fiboMiddleBuffer //
);
//
CopyFiboLower(
zIndex,
loopback,
conditions.fiboLowerBuffer //
);
//
CopyZigZag(
zIndex,
loopback,
conditions.zigzagBuffer //
);
//
CopySHH(
zIndex,
loopback,
conditions.sHHBuffer //
);
//
CopySLL(
zIndex,
loopback,
conditions.sLLBuffer //
);
//
CopyMHH(
zIndex,
loopback,
conditions.mHHBuffer //
);
//
CopyMLL(
zIndex,
loopback,
conditions.mLLBuffer //
);
//
CopyLHH(
zIndex,
loopback,
conditions.lHHBuffer //
);
//
CopyLLL(
zIndex,
loopback,
conditions.lLLBuffer //
);
//
CopyHHH(
zIndex,
loopback,
conditions.hHHBuffer //
);
//
CopyHLL(
zIndex,
loopback,
conditions.hLLBuffer //
);
//
CopyHKOpen(
zIndex,
loopback,
conditions.hkOpenBuffer //
);
//
CopyHKHigh(
zIndex,
loopback,
conditions.hkHighBuffer //
);
//
CopyHKLow(
zIndex,
loopback,
conditions.hkLowBuffer //
);
//
CopyHKClose(
zIndex,
loopback,
conditions.hkCloseBuffer //
);
//
CopyHKColor(
zIndex,
loopback,
conditions.hkColorBuffer //
);
//
// Conditions ...
//
return result;
}
//
// Pivot Actions ...
/**
* Check Specified Bar has MA Cross or not ...
*
* @param dir: reference for holds cross Direction ...
* @param barIndex: int, Specified Bar Index ...
* @param validCrossDiffMultiplier: double, validate diff between MAs on Cross happens ...
*
* @return ( bool )
*/
bool HasMACross(
ENUM_X_DIRECTION &dir,
int barIndex = 0,
double validCrossDiffMultiplier = 1 //
)
{
//
bool result = false;
//
// Prepare ...
dir = X_DIRECTION_NONE;
//
// Normalize ...
barIndex = NormalizeInt(barIndex, 0);
validCrossDiffMultiplier = NormalizeDouble(validCrossDiffMultiplier, 0);
//
double fast[];
double slow[];
double upper[];
double lower[];
int count = ReadMAValues(
fast,
slow,
upper,
lower,
barIndex,
2 //
);
//
bool isBullish = false;
bool isBearish = false;
//
// Validate Readed Values ...
result = IsValidSize(count) && count >= 2;
if (result)
{
//
// Detect Direction Change ...
//
bool notEmpty =
NotEmptyZero(fast[0]) &&
NotEmptyZero(fast[1]) &&
NotEmptyZero(slow[0]) &&
NotEmptyZero(slow[1]);
//
isBullish =
notEmpty &&
fast[0] > slow[0] &&
fast[1] < slow[1];
//
isBearish =
notEmpty &&
fast[0] < slow[0] &&
fast[1] > slow[1];
//
result =
isBullish ||
isBearish;
//
// Validate Direction Change ...
if (result &&
validCrossDiffMultiplier > 0)
{
//
double _points = GetPoints(GetSymbol());
double diff = MathAbs(fast[0] - slow[0]);
//
result = diff >= (validCrossDiffMultiplier * _points);
}
}
//
if (result)
{
//
// Setting Direction ...
dir =
isBullish
? X_DIRECTION_BULLISH
: isBearish
? X_DIRECTION_BEARISH
: X_DIRECTION_NONE;
}
//
// Cleanup Resources ...
XClean(fast);
XClean(slow);
XClean(upper);
XClean(lower);
//
return result;
}
/**
* Check Specified Bar has HK Switch or not ...
*
* @param dir: reference for holds cross Direction ...
* @param barIndex: int, Specified Bar Index ...
*
* @return ( bool )
*/
bool HasHKSwitch(
ENUM_X_DIRECTION &dir,
int barIndex = 0 //
)
{
//
bool result = false;
//
// Prepare ...
dir = X_DIRECTION_NONE;
//
// Normalize ...
barIndex = NormalizeInt(barIndex, 0);
//
double low[];
double open[];
double high[];
double close[];
int count = ReadHKBars(
open,
high,
low,
close,
barIndex,
2 //
);
//
bool isBullish = false;
bool isBearish = false;
//
// Validate Readed Values ...
result = IsValidSize(count) && count >= 2;
if (result)
{
//
// Detect Direction Change ...
//
bool notEmpty =
NotEmptyZero(open[0]) &&
NotEmptyZero(open[1]) &&
NotEmptyZero(close[0]) &&
NotEmptyZero(close[1]);
//
isBullish =
notEmpty &&
open[0] < close[0] &&
open[1] > close[1];
//
isBearish =
notEmpty &&
open[0] > close[0] &&
open[1] < close[1];
//
result =
isBullish ||
isBearish;
}
//
if (result)
{
//
// Setting Direction ...
dir =
isBullish
? X_DIRECTION_BULLISH
: isBearish
? X_DIRECTION_BEARISH
: X_DIRECTION_NONE;
}
//
// Cleanup Resources ...
XClean(low);
XClean(open);
XClean(high);
XClean(close);
//
return result;
}
/**
* Check Specified Bar has SAR Switch or not ...
*
* @param dir: reference for holds cross Direction ...
* @param barIndex: int, Specified Bar Index ...
*
* @return ( bool )
*/
bool HasSARSwitch(
ENUM_X_DIRECTION &dir,
int barIndex = 0 //
)
{
//
bool result = false;
//
// Prepare ...
dir = X_DIRECTION_NONE;
//
// Normalize ...
barIndex = NormalizeInt(barIndex, 0);
//
// Validate ...
result = mHandler != INVALID_HANDLE;
if (!result)
{
return result;
}
//
double sars[];
int count = CopyBuffer(
mHandler,
XFIMA_SAR_STATE_LINE,
barIndex,
2,
sars //
);
//
bool isBullish = false;
bool isBearish = false;
//
// Validate Readed Values ...
result = IsValidSize(count) && count >= 2;
if (result)
{
//
// Detect Direction Change ...
//
isBullish =
sars[0] >= 1 &&
sars[1] <= -1;
//
isBearish =
sars[0] <= -1 &&
sars[1] >= 1;
//
result =
isBullish ||
isBearish;
}
//
if (result)
{
//
// Setting Direction ...
dir =
isBullish
? X_DIRECTION_BULLISH
: isBearish
? X_DIRECTION_BEARISH
: X_DIRECTION_NONE;
}
//
// Cleanup Resources ...
XClean(sars);
//
return result;
}
/**
* Extract Specified Kind of Pivots ...
*
* @param pivots: XPivot, refrence Collection to hold Extracted pivots ...
* @param barIndex: int, Specified Bar Index ...
* @param requiredNumberOFPivots: int, Specified which Number of Pivots must be Extracted ...
* @param maxAllowedLoopbackLength: int, Specified Maximum Loopback Length for Pivot Extraction ...
* @param validationLength: int, Specified Pivots Validation Length ignore if <= 0 ...
*
* @return ( int )
*/
int ExtractPVPivots(
XPivot &pivots[],
int barIndex = 0,
int requiredNumberOFPivots = 50,
int maxAllowedLoopbackLength = 1500,
int validationLength = 0 //
)
{
//
int result = 0;
//
// Prepare ...
SpecifiedClean(pivots);
//
// Normalize ...
barIndex = NormalizeInt(barIndex, 0);
validationLength = NormalizeInt(validationLength, 0);
requiredNumberOFPivots = NormalizeInt(requiredNumberOFPivots, 2);
maxAllowedLoopbackLength = NormalizeInt(maxAllowedLoopbackLength, 50);
//
// Validate ...
if (mHandler == INVALID_HANDLE)
{
return result;
}
//
bool lookupPeaks = true;
bool lookupVales = true;
//
XOHCL iBar;
XPivot iPivot;
bool has = false;
int idx = barIndex - 1;
int samePeaksCount = 0;
int sameValesCount = 0;
double tmpPeaksBuffer[];
double tmpValesBuffer[];
string symbol = GetSymbol();
double iPValue = EMPTY_VALUE;
double iVValue = EMPTY_VALUE;
double pPValue = EMPTY_VALUE;
double pVValue = EMPTY_VALUE;
ENUM_TIMEFRAMES period = GetPeriod();
ENUM_X_DIRECTION iDir = X_DIRECTION_NONE;
ENUM_X_PIVOT_TYPE iType = X_PIVOT_TYPE_NONE;
int maxAllowed = barIndex + maxAllowedLoopbackLength - 1;
while (idx < maxAllowed &&
ArraySize(pivots) < requiredNumberOFPivots)
{
//
idx++;
//
// Prepare ...
iBar.Clean();
iPivot.Clean();
SpecifiedClean(tmpPeaksBuffer);
SpecifiedClean(tmpValesBuffer);
//
// Ignore First Item ...
if (idx == barIndex)
{
continue;
}
//
// Initialize Bar ...
has = iBar.Init(
symbol,
period,
idx //
);
if (!has)
{
continue;
}
//
// Detecting ...
//
// Peak ...
if (lookupPeaks)
{
//
// Reading Buffer ...
CopyBuffer(
mHandler, // Handler ...
XFIMA_PEAK_LINE, // Handler Buffer Number ...
idx, // Bar Index ...
2, // Number of Requirements ...
tmpPeaksBuffer // Buffer ...
);
ArraySetAsSeries(tmpPeaksBuffer, true);
//
// Reading Values ...
iPValue = tmpPeaksBuffer[0];
pPValue = tmpPeaksBuffer[1];
//
// Validate Value ...
if (NotEmptyZero(iPValue))
{
//
// Check New Peak ...
has =
!NotEmptyZero(pPValue)
? true
: iPValue != pPValue;
if (has)
{
//
// Calculate and Validate Type ...
// Peaks Only Valid when Confirmed by Bar High ...
iType =
iPValue == iBar.high
? X_PIVOT_TYPE_PEAK
: X_PIVOT_TYPE_NONE;
has = IsXValid(iType);
//
// Calculate and Validate Dir ...
iDir = IsXPeak(iType)
? X_DIRECTION_BEARISH
: X_DIRECTION_NONE;
has = has &&
HasDirection(iDir);
//
// Check Validation Length ...
has =
has &&
(validationLength <= 0
? true
: samePeaksCount >= validationLength);
if (has)
{
//
// Initialize and Validate Pivot ...
has = iPivot.Init(
iPValue,
iBar.time,
symbol,
iDir,
period,
iType //
);
if (has)
{
//
// Add Pivot to Collection only if not Exists ...
AddIfNotExists(
iPivot,
pivots //
);
}
}
//
// Cleanup Resources ...
iPivot.Clean();
samePeaksCount = 0;
}
else if (iPValue == pPValue)
{
samePeaksCount++;
}
}
}
//
// Vale ...
if (lookupVales)
{
//
// Reading Buffer ...
CopyBuffer(
mHandler, // Handler ...
XFIMA_VALE_LINE, // Handler Buffer Number ...
idx, // Bar Index ...
2, // Number of Requirements ...
tmpValesBuffer // Buffer ...
);
ArraySetAsSeries(tmpValesBuffer, true);
//
// Reading Values ...
iVValue = tmpValesBuffer[0];
pVValue = tmpValesBuffer[1];
//
// Validate Value ...
if (NotEmptyZero(iVValue))
{
//
// Check New Vale ...
has =
!NotEmptyZero(pVValue)
? true
: iVValue != pVValue;
if (has)
{
//
// Calculate and Validate Type ...
// Vales Only Valid when Confirmed by Bar Low ...
iType =
iVValue == iBar.low
? X_PIVOT_TYPE_VALE
: X_PIVOT_TYPE_NONE;
has = IsXValid(iType);
//
// Calculate and Validate Dir ...
iDir = IsXVale(iType)
? X_DIRECTION_BULLISH
: X_DIRECTION_NONE;
has = has &&
HasDirection(iDir);
//
// Check Validation Length ...
has =
has &&
(validationLength <= 0
? true
: sameValesCount >= validationLength);
if (has)
{
//
// Initialize and Validate Pivot ...
has = iPivot.Init(
iVValue,
iBar.time,
symbol,
iDir,
period,
iType //
);
if (has)
{
//
// Add Pivot to Collection only if not Exists ...
AddIfNotExists(
iPivot,
pivots //
);
}
}
//
// Cleanup Resources ...
iPivot.Clean();
sameValesCount = 0;
}
else if (iVValue == pVValue)
{
sameValesCount++;
}
}
}
//
// Cleanup Resources ...
iBar.Clean();
iPivot.Clean();
SpecifiedClean(tmpPeaksBuffer);
SpecifiedClean(tmpValesBuffer);
//
// Check Moving Forward Condition ...
has =
idx < maxAllowed &&
ArraySize(pivots) < requiredNumberOFPivots;
if (!has)
{
break;
}
}
//
result = ArraySize(pivots);
//
// Cleanup Resources ...
iBar.Clean();
iPivot.Clean();
SpecifiedClean(tmpPeaksBuffer);
SpecifiedClean(tmpValesBuffer);
//
return result;
}
/**
* Extract Specified Kind of Pivots ...
*
* @param pivots: XPivot, refrence Collection to hold Extracted pivots ...
* @param barIndex: int, Specified Bar Index ...
* @param requiredNumberOFPivots: int, Specified which Number of Pivots must be Extracted ...
* @param validCrossDiffMultiplier: double, validate diff between MAs on Cross happens ...
* @param maxAllowedLoopbackLength: int, Specified Maximum Loopback Length for Pivot Extraction ...
*
* @return ( int )
*/
int ExtractMAPivots(
XPivot &pivots[],
int barIndex = 0,
int requiredNumberOFPivots = 50,
double validCrossDiffMultiplier = 1,
int maxAllowedLoopbackLength = 1500 //
)
{
//
int result = 0;
//
// Prepare ...
SpecifiedClean(pivots);
//
// Normalize ...
barIndex = NormalizeInt(barIndex, 0);
requiredNumberOFPivots = NormalizeInt(requiredNumberOFPivots, 2);
maxAllowedLoopbackLength = NormalizeInt(maxAllowedLoopbackLength, 50);
validCrossDiffMultiplier = NormalizeDouble(validCrossDiffMultiplier, 0);
//
// Validate ...
if (mHandler == INVALID_HANDLE)
{
return result;
}
//
double fast[];
double slow[];
XPivot iPivot;
int count = 0;
double upper[];
double lower[];
bool has = false;
int idx = barIndex - 1;
datetime iPivotTime = NULL;
string symbol = GetSymbol();
double iFValue = EMPTY_VALUE;
double pFValue = EMPTY_VALUE;
double iSValue = EMPTY_VALUE;
double pSValue = EMPTY_VALUE;
bool isSwitchedToBullish = false;
bool isSwitchedToBearish = false;
double iSelectedValue = EMPTY_VALUE;
ENUM_TIMEFRAMES period = GetPeriod();
ENUM_X_DIRECTION iDir = X_DIRECTION_NONE;
ENUM_X_PIVOT_TYPE iType = X_PIVOT_TYPE_NONE;
int maxAllowed = barIndex + maxAllowedLoopbackLength - 1;
while (idx < maxAllowed &&
ArraySize(pivots) < requiredNumberOFPivots)
{
//
idx++;
//
// Prepare ...
iPivot.Clean();
SpecifiedClean(fast);
SpecifiedClean(slow);
SpecifiedClean(upper);
SpecifiedClean(lower);
//
// Ignore First Item ...
if (idx == barIndex)
{
continue;
}
//
// Reading Buffer ...
count = ReadMAValues(
fast,
slow,
upper,
lower,
idx,
2 //
);
has = IsValidSize(count);
//
// Reading Values ...
//
iFValue = fast[0];
pFValue = fast[1];
//
iSValue = slow[0];
pSValue = slow[1];
//
// Validate Value ...
has =
HasMACross(
iDir,
idx,
validCrossDiffMultiplier //
) &&
NotEmptyZero(iFValue) &&
NotEmptyZero(iSValue) &&
NotEmptyZero(pFValue) &&
NotEmptyZero(pSValue);
if (has)
{
//
// Check Direction Changed ...
isSwitchedToBullish = IsXBullish(iDir);
isSwitchedToBearish = IsXBearish(iDir);
has =
isSwitchedToBullish ||
isSwitchedToBearish;
if (has)
{
//
// Calculate and Validate Type ...
// Peaks Only Valid when Confirmed by Bar High ...
iType =
isSwitchedToBearish
? X_PIVOT_TYPE_PEAK
: isSwitchedToBullish
? X_PIVOT_TYPE_VALE
: X_PIVOT_TYPE_NONE;
has = IsXValid(iType);
//
// Calculate and Validate Dir ...
iDir = IsXPeak(iType)
? X_DIRECTION_BEARISH
: IsXVale(iType)
? X_DIRECTION_BULLISH
: X_DIRECTION_NONE;
has = has &&
HasDirection(iDir);
//
if (has)
{
//
iPivotTime = GetBarTime(
symbol,
period,
idx //
);
//
// Select Value based on Pivot Type ...
iSelectedValue = IsXPeak(iType)
? MathMax(iFValue, iSValue)
: MathMin(iFValue, iSValue);
//
// Initialize and Validate Pivot ...
has = iPivot.Init(
iSelectedValue,
iPivotTime,
symbol,
iDir,
period,
iType //
);
if (has)
{
//
// Add Pivot to Collection only if not Exists ...
AddIfNotExists(
iPivot,
pivots //
);
}
}
//
// Cleanup Resources ...
iPivot.Clean();
}
}
//
// Cleanup Resources ...
iPivot.Clean();
SpecifiedClean(fast);
SpecifiedClean(slow);
SpecifiedClean(upper);
SpecifiedClean(lower);
//
// Check Moving Forward Condition ...
has =
idx < maxAllowed &&
ArraySize(pivots) < requiredNumberOFPivots;
if (!has)
{
break;
}
}
//
result = ArraySize(pivots);
//
// Cleanup Resources ...
iPivot.Clean();
SpecifiedClean(fast);
SpecifiedClean(slow);
SpecifiedClean(upper);
SpecifiedClean(lower);
//
return result;
}
/**
* Extract Specified Kind of Pivots ...
*
* @param pivots: XPivot, refrence Collection to hold Extracted pivots ...
* @param barIndex: int, Specified Bar Index ...
* @param requiredNumberOFPivots: int, Specified which Number of Pivots must be Extracted ...
* @param maxAllowedLoopbackLength: int, Specified Maximum Loopback Length for Pivot Extraction ...
*
* @return ( int )
*/
int ExtractHKPivots(
XPivot &pivots[],
int barIndex = 0,
int requiredNumberOFPivots = 50,
int maxAllowedLoopbackLength = 1500 //
)
{
//
int result = 0;
//
// Prepare ...
SpecifiedClean(pivots);
//
// Normalize ...
barIndex = NormalizeInt(barIndex, 0);
requiredNumberOFPivots = NormalizeInt(requiredNumberOFPivots, 2);
maxAllowedLoopbackLength = NormalizeInt(maxAllowedLoopbackLength, 50);
//
// Validate ...
if (mHandler == INVALID_HANDLE)
{
return result;
}
//
double low[];
double open[];
XPivot iPivot;
int count = 0;
double high[];
double close[];
bool has = false;
int idx = barIndex - 1;
datetime iPivotTime = NULL;
string symbol = GetSymbol();
bool isSwitchedToBullish = false;
bool isSwitchedToBearish = false;
double iSelectedValue = EMPTY_VALUE;
ENUM_TIMEFRAMES period = GetPeriod();
ENUM_X_DIRECTION iDir = X_DIRECTION_NONE;
ENUM_X_PIVOT_TYPE iType = X_PIVOT_TYPE_NONE;
int maxAllowed = barIndex + maxAllowedLoopbackLength - 1;
while (idx < maxAllowed &&
ArraySize(pivots) < requiredNumberOFPivots)
{
//
idx++;
//
// Prepare ...
iPivot.Clean();
SpecifiedClean(low);
SpecifiedClean(open);
SpecifiedClean(high);
SpecifiedClean(close);
//
// Ignore First Item ...
if (idx == barIndex)
{
continue;
}
//
// Reading Buffer ...
count = ReadHKBars(
open,
high,
low,
close,
idx,
2 //
);
has = IsValidSize(count);
//
// Validate Value ...
has =
HasHKSwitch(
iDir,
idx //
) &&
NotEmptyZero(open[0]) &&
NotEmptyZero(open[1]) &&
NotEmptyZero(close[0]) &&
NotEmptyZero(close[1]);
if (has)
{
//
// Check Direction Changed ...
isSwitchedToBullish = IsXBullish(iDir);
isSwitchedToBearish = IsXBearish(iDir);
has =
isSwitchedToBullish ||
isSwitchedToBearish;
if (has)
{
//
// Calculate and Validate Type ...
// Peaks Only Valid when Confirmed by Bar High ...
iType =
isSwitchedToBearish
? X_PIVOT_TYPE_PEAK
: isSwitchedToBullish
? X_PIVOT_TYPE_VALE
: X_PIVOT_TYPE_NONE;
has = IsXValid(iType);
//
// Calculate and Validate Dir ...
iDir = IsXPeak(iType)
? X_DIRECTION_BEARISH
: IsXVale(iType)
? X_DIRECTION_BULLISH
: X_DIRECTION_NONE;
has = has &&
HasDirection(iDir);
//
if (has)
{
//
iPivotTime = GetBarTime(
symbol,
period,
idx //
);
//
// Select Value based on Pivot Type ...
iSelectedValue = IsXPeak(iType)
? MathMax(open[0], close[0])
: MathMin(open[0], close[0]);
//
// Initialize and Validate Pivot ...
has = iPivot.Init(
iSelectedValue,
iPivotTime,
symbol,
iDir,
period,
iType //
);
if (has)
{
//
// Add Pivot to Collection only if not Exists ...
AddIfNotExists(
iPivot,
pivots //
);
}
}
//
// Cleanup Resources ...
iPivot.Clean();
}
}
//
// Cleanup Resources ...
iPivot.Clean();
SpecifiedClean(low);
SpecifiedClean(open);
SpecifiedClean(high);
SpecifiedClean(close);
//
// Check Moving Forward Condition ...
has =
idx < maxAllowed &&
ArraySize(pivots) < requiredNumberOFPivots;
if (!has)
{
break;
}
}
//
result = ArraySize(pivots);
//
// Cleanup Resources ...
iPivot.Clean();
SpecifiedClean(low);
SpecifiedClean(open);
SpecifiedClean(high);
SpecifiedClean(close);
//
return result;
}
/**
* Extract Specified Kind of Pivots ...
*
* @param pivots: XPivot, refrence Collection to hold Extracted pivots ...
* @param barIndex: int, Specified Bar Index ...
* @param requiredNumberOFPivots: int, Specified which Number of Pivots must be Extracted ...
* @param maxAllowedLoopbackLength: int, Specified Maximum Loopback Length for Pivot Extraction ...
*
* @return ( int )
*/
int ExtractSARPivots(
XPivot &pivots[],
int barIndex = 0,
int requiredNumberOFPivots = 50,
int maxAllowedLoopbackLength = 1500 //
)
{
//
int result = 0;
//
// Prepare ...
SpecifiedClean(pivots);
//
// Normalize ...
barIndex = NormalizeInt(barIndex, 0);
requiredNumberOFPivots = NormalizeInt(requiredNumberOFPivots, 2);
maxAllowedLoopbackLength = NormalizeInt(maxAllowedLoopbackLength, 50);
//
// Validate ...
if (mHandler == INVALID_HANDLE)
{
return result;
}
//
XOHCL iBar;
XOHCL pBar;
XPivot iPivot;
bool has = false;
double tmpSarBuffer[];
int idx = barIndex - 1;
string symbol = GetSymbol();
double iValue = EMPTY_VALUE;
double pValue = EMPTY_VALUE;
bool isSwitchedToBullish = false;
bool isSwitchedToBearish = false;
ENUM_TIMEFRAMES period = GetPeriod();
ENUM_X_DIRECTION iDir = X_DIRECTION_NONE;
ENUM_X_PIVOT_TYPE iType = X_PIVOT_TYPE_NONE;
int maxAllowed = barIndex + maxAllowedLoopbackLength - 1;
while (idx < maxAllowed &&
ArraySize(pivots) < requiredNumberOFPivots)
{
//
idx++;
//
// Prepare ...
iBar.Clean();
pBar.Clean();
iPivot.Clean();
SpecifiedClean(tmpSarBuffer);
//
// Ignore First Item ...
if (idx == barIndex)
{
continue;
}
//
// Initialize Bar ...
has = iBar.Init(
symbol,
period,
idx //
);
has =
has &&
iBar.GetPreviousBar(pBar);
if (!has)
{
continue;
}
//
// Reading Buffer ...
CopyBuffer(
mHandler, // Handler ...
XFIMA_SAR_LINE, // Handler Buffer Number ...
idx, // Bar Index ...
2, // Number of Requirements ...
tmpSarBuffer // Buffer ...
);
ArraySetAsSeries(tmpSarBuffer, true);
//
// Reading Values ...
iValue = tmpSarBuffer[0];
pValue = tmpSarBuffer[1];
//
// Validate Value ...
if (NotEmptyZero(iValue))
{
//
// Check Sar Direction Changed ...
isSwitchedToBullish = iValue < iBar.low &&
pValue > pBar.high;
isSwitchedToBearish = iValue > iBar.high &&
pValue < pBar.low;
has =
isSwitchedToBullish ||
isSwitchedToBearish;
if (has)
{
//
// Calculate and Validate Type ...
// Peaks Only Valid when Confirmed by Bar High ...
iType =
isSwitchedToBearish
? X_PIVOT_TYPE_PEAK
: isSwitchedToBullish
? X_PIVOT_TYPE_VALE
: X_PIVOT_TYPE_NONE;
has = IsXValid(iType);
//
// Calculate and Validate Dir ...
iDir = IsXPeak(iType)
? X_DIRECTION_BEARISH
: IsXVale(iType)
? X_DIRECTION_BULLISH
: X_DIRECTION_NONE;
has = has &&
HasDirection(iDir);
//
// TODO: we can also Add other Validations Here ...
//
if (has)
{
//
// Initialize and Validate Pivot ...
has = iPivot.Init(
iValue,
iBar.time,
symbol,
iDir,
period,
iType //
);
if (has)
{
//
// Add Pivot to Collection only if not Exists ...
AddIfNotExists(
iPivot,
pivots //
);
}
}
//
// Cleanup Resources ...
iPivot.Clean();
}
}
//
// Cleanup Resources ...
iBar.Clean();
pBar.Clean();
iPivot.Clean();
SpecifiedClean(tmpSarBuffer);
//
// Check Moving Forward Condition ...
has =
idx < maxAllowed &&
ArraySize(pivots) < requiredNumberOFPivots;
if (!has)
{
break;
}
}
//
result = ArraySize(pivots);
//
// Cleanup Resources ...
iBar.Clean();
pBar.Clean();
iPivot.Clean();
SpecifiedClean(tmpSarBuffer);
//
return result;
}
/**
* Extract Specified Kind of Pivots ...
*
* @param pivots: XPivot, refrence Collection to hold Extracted pivots ...
* @param barIndex: int, Specified Bar Index ...
* @param requiredNumberOFPivots: int, Specified which Number of Pivots must be Extracted ...
* @param maxAllowedLoopbackLength: int, Specified Maximum Loopback Length for Pivot Extraction ...
*
* @return ( int )
*/
int ExtractZigZagPivots(
XPivot &pivots[],
int barIndex = 0,
int requiredNumberOFPivots = 50,
int maxAllowedLoopbackLength = 1500 //
)
{
//
int result = 0;
//
// Prepare ...
SpecifiedClean(pivots);
//
// Normalize ...
barIndex = NormalizeInt(barIndex, 0);
requiredNumberOFPivots = NormalizeInt(requiredNumberOFPivots, 2);
maxAllowedLoopbackLength = NormalizeInt(maxAllowedLoopbackLength, 50);
//
// Validate ...
if (mHandler == INVALID_HANDLE)
{
return result;
}
//
XOHCL iBar;
XPivot iPivot;
bool has = false;
int idx = barIndex - 1;
double tmpZigZagBuffer[];
double iValue = EMPTY_VALUE;
string symbol = GetSymbol();
ENUM_TIMEFRAMES period = GetPeriod();
ENUM_X_DIRECTION iDir = X_DIRECTION_NONE;
ENUM_X_PIVOT_TYPE iType = X_PIVOT_TYPE_NONE;
int maxAllowed = barIndex + maxAllowedLoopbackLength - 1;
while (idx < maxAllowed &&
ArraySize(pivots) < requiredNumberOFPivots)
{
//
idx++;
//
// Prepare ...
iBar.Clean();
iPivot.Clean();
SpecifiedClean(tmpZigZagBuffer);
//
// Ignore First Item ...
if (idx == barIndex)
{
continue;
}
//
// Initialize Bar ...
has = iBar.Init(
symbol,
period,
idx //
);
if (!has)
{
continue;
}
//
// Reading Buffer ...
CopyBuffer(
mHandler, // Handler ...
XFIMA_ZIGZAG_LINE, // Handler Buffer Number ...
idx, // Bar Index ...
1, // Number of Requirements ...
tmpZigZagBuffer // Buffer ...
);
ArraySetAsSeries(tmpZigZagBuffer, true);
//
// Read and Validate Value ...
iValue = tmpZigZagBuffer[0];
has = NotEmptyZero(iValue);
if (!has)
{
//
iBar.Clean();
SpecifiedClean(tmpZigZagBuffer);
continue;
}
//
// Calculate and Validate Type ...
iType =
iValue == iBar.high
? X_PIVOT_TYPE_PEAK
: iValue == iBar.low
? X_PIVOT_TYPE_VALE
: X_PIVOT_TYPE_NONE;
has = IsXValid(iType);
if (!has)
{
//
iBar.Clean();
SpecifiedClean(tmpZigZagBuffer);
continue;
}
//
// Calculate and Validate Dir ...
iDir =
IsXVale(iType)
? X_DIRECTION_BULLISH
: IsXPeak(iType)
? X_DIRECTION_BEARISH
: X_DIRECTION_NONE;
has = HasDirection(iDir);
if (!has)
{
//
iBar.Clean();
SpecifiedClean(tmpZigZagBuffer);
continue;
}
//
// Initialize and Validate Pivot ...
has = iPivot.Init(
iValue,
iBar.time,
symbol,
iDir,
period,
iType //
);
if (has)
{
//
// Add Pivot to Collection only if not Exists ...
AddIfNotExists(
iPivot,
pivots //
);
}
//
// Cleanup Resources ...
iBar.Clean();
iPivot.Clean();
SpecifiedClean(tmpZigZagBuffer);
//
// Check Moving Forward Condition ...
has =
idx < maxAllowed &&
ArraySize(pivots) < requiredNumberOFPivots;
if (!has)
{
break;
}
}
//
result = ArraySize(pivots);
//
// Cleanup Resources ...
iBar.Clean();
iPivot.Clean();
SpecifiedClean(tmpZigZagBuffer);
//
return result;
}
/**
* Extract Validated Zones ...
*
* @param zones: XBoxZone, collection reference to holds results ...
* @param barIndex: int, Specified Bar Index ...
* @param requiredNumberOFZones: int, required Number of Zones ...
* @param breakValidLength: int, Breake Validation Length of Zones ...
* @param validateFakeBreakes: bool, Validation Fake Breaked Zones ...
* @param shadowMultiplier: double a Shadow Multiplier for Validation ...
* @param validationStrength: double, Minimum Strngth Multiplier in Point to Validate ...
* @param validationLength: int, Validation Length of Zones ...
* @param maxAllowedLoopbackLength: int, max Allowed Loopback Length ...
*
* @return ( int )
*/
int ExtractHKZones(
XBoxZone &zones[],
int barIndex = 0,
int requiredNumberOFZones = 50,
int breakValidLength = 3,
bool validateFakeBreakes = true,
double shadowMultiplier = 3,
double validationStrength = 1,
int validationLength = 21,
int maxAllowedLoopbackLength = 1500 //
)
{
//
int result = 0;
//
// Prepare ...
SpecifiedClean(zones);
//
// Normalize ...
barIndex = NormalizeInt(barIndex, 0);
validationLength = NormalizeInt(validationLength, 7);
shadowMultiplier = NormalizeDouble(shadowMultiplier, 1);
validationStrength = NormalizeDouble(validationStrength, 1);
requiredNumberOFZones = NormalizeInt(requiredNumberOFZones, 5);
maxAllowedLoopbackLength = NormalizeInt(maxAllowedLoopbackLength, 100);
//
// Reading Values ...
//
string symbol = GetSymbol();
ENUM_TIMEFRAMES period = GetPeriod();
double minAllowedStrength = (validationStrength * GetPoints(symbol));
//
int count = 0;
XBoxZone zone;
double hkLows[];
bool has = false;
double hkOpens[];
double hkHighs[];
double hkCloses[];
int start = barIndex;
bool isBullish = false;
bool isBearish = false;
double up = EMPTY_VALUE;
double down = EMPTY_VALUE;
double body = EMPTY_VALUE;
double range = EMPTY_VALUE;
bool lowShadowPassed = false;
bool highShadowPassed = false;
double lowShadow = EMPTY_VALUE;
double highShadow = EMPTY_VALUE;
double startHKLow = EMPTY_VALUE;
double startHKOpen = EMPTY_VALUE;
double startHKHigh = EMPTY_VALUE;
double startHKClose = EMPTY_VALUE;
ENUM_X_DIRECTION dir = X_DIRECTION_NONE;
int end = start + maxAllowedLoopbackLength;
for (int i = start; i < end; i++)
{
//
// Cleanup ...
zone.Clean();
dir = X_DIRECTION_NONE;
//
// Reading HK Buffesr ...
count = ReadHKBars(
hkOpens,
hkHighs,
hkLows,
hkCloses,
i,
1 //
);
has = IsValidSize(count);
if (!has)
{
continue;
}
//
// Initialized Start Bar ...
if (i == start)
{
//
startHKLow = hkLows[0];
startHKOpen = hkOpens[0];
startHKHigh = hkHighs[0];
startHKClose = hkCloses[0];
}
//
// Check Direction ...
isBullish = hkOpens[0] < hkCloses[0];
isBearish = hkOpens[0] > hkCloses[0];
dir =
(isBullish && !isBearish)
? X_DIRECTION_BULLISH
: (isBearish && !isBullish)
? X_DIRECTION_BEARISH
: X_DIRECTION_NONE;
has = HasDirection(dir);
if (!has)
{
continue;
}
//
// Calculate Requirements for Processing ...
up = isBullish
? hkCloses[0]
: hkOpens[0];
down = isBullish
? hkOpens[0]
: hkCloses[0];
body = MathAbs(up - down);
range = hkHighs[0] - hkLows[0];
highShadow = hkHighs[0] - up;
lowShadow = down - hkLows[0];
//
// Detecting Shadows ...
//
// Low Shadow ...
lowShadowPassed = lowShadow >= (shadowMultiplier * highShadow);
//
// High Shadow ...
highShadowPassed = highShadow >= (shadowMultiplier * lowShadow);
//
has = (lowShadowPassed && !highShadowPassed) ||
(highShadowPassed && !lowShadowPassed);
if (!has)
{
continue;
}
//
// Filling Zone ...
//
zone.symbol = symbol;
zone.period = period;
zone.from = GetBarTime(
zone.symbol,
zone.period,
i //
);
zone.dir = lowShadowPassed
? X_DIRECTION_BULLISH
: highShadowPassed
? X_DIRECTION_BEARISH
: X_DIRECTION_NONE;
//
zone.upper =
IsXBullish(zone.dir)
? down
: IsXBearish(zone.dir)
? hkHighs[0]
: EMPTY_VALUE;
//
zone.lower =
IsXBullish(zone.dir)
? hkLows[0]
: IsXBearish(zone.dir)
? up
: EMPTY_VALUE;
//
zone.to = TimeCurrent();
zone.type = "XHK_" + (IsXBullish(zone.dir) ? "Support" : IsXBearish(zone.dir) ? "Resistance"
: "") +
"_" + ToXString(TimeToSeconds(zone.from));
//
// Validate ...
has =
zone.IsValid() &&
HasDirection(zone.dir) &&
NotEmptyZero(zone.upper) &&
NotEmptyZero(zone.lower) &&
(zone.IsBullish()
? startHKLow > zone.upper
: startHKHigh < zone.lower) &&
(zone.upper - zone.lower) >= minAllowedStrength &&
ValidateHKZone(zone, validationLength, breakValidLength, validateFakeBreakes);
if (has)
{
//
AddIfNotExists(
zone,
zones //
);
}
//
// Cleanup Resources ...
zone.Clean();
//
// Validating ...
result = ArraySize(zones);
has = IsValidSize(result) &&
result >= requiredNumberOFZones;
if (has)
{
break;
}
}
//
// Cleanup Resources ...
zone.Clean();
SpecifiedClean(hkLows);
SpecifiedClean(hkOpens);
SpecifiedClean(hkHighs);
SpecifiedClean(hkCloses);
//
return result;
}
//
// Values Retrievers ...
//
// Fast MA ...
//
double GetMAFast(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(maFastBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return maFastBuffer[barIndex];
}
//
int CopyMAFast(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
maFastBuffer,
buffer,
forceClean
//
);
}
//
// Fast MA State ...
//
double GetMAFastState(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(maFastStateBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return maFastStateBuffer[barIndex];
}
//
int CopyMAFastState(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
maFastStateBuffer,
buffer,
forceClean
//
);
}
//
// Slow MA ...
//
double GetMASlow(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(maSlowBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return maSlowBuffer[barIndex];
}
//
int CopyMASlow(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
maSlowBuffer,
buffer,
forceClean
//
);
}
//
// Slow MA State ...
//
double GetMASlowState(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(maSlowStateBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return maSlowStateBuffer[barIndex];
}
//
int CopyMASlowState(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
maSlowStateBuffer,
buffer,
forceClean
//
);
}
//
// Upper MA ...
//
double GetMABandUpper(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(maBandUpperBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return maBandUpperBuffer[barIndex];
}
//
int CopyMABandUpper(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
maBandUpperBuffer,
buffer,
forceClean
//
);
}
//
// Lower MA ...
//
double GetMABandLower(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(maBandLowerBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return maBandLowerBuffer[barIndex];
}
//
int CopyMABandLower(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
maBandLowerBuffer,
buffer,
forceClean
//
);
}
//
// SAR ...
//
double GetSar(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(sarBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return sarBuffer[barIndex];
}
//
int CopySar(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
sarBuffer,
buffer,
forceClean
//
);
}
//
// SAR State ...
//
double GetSarState(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(sarStateBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return sarStateBuffer[barIndex];
}
//
int CopySarState(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
sarStateBuffer,
buffer,
forceClean
//
);
}
//
// PEAK ...
//
double GetPeak(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(peakBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return peakBuffer[barIndex];
}
//
int CopyPeak(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
peakBuffer,
buffer,
forceClean
//
);
}
//
// VALE ...
//
double GetVale(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(valeBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return valeBuffer[barIndex];
}
//
int CopyVale(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
valeBuffer,
buffer,
forceClean
//
);
}
//
// FIBO Zone ...
//
// FIBO Upper ...
//
double GetFiboUpper(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(fiboUpperBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return fiboUpperBuffer[barIndex];
}
//
int CopyFiboUpper(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
fiboUpperBuffer,
buffer,
forceClean
//
);
}
//
// FIBO Middle ...
//
double GetFiboMiddle(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(fiboMiddleBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return fiboMiddleBuffer[barIndex];
}
//
int CopyFiboMiddle(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
fiboMiddleBuffer,
buffer,
forceClean
//
);
}
//
// FIBO Lower ...
//
double GetFiboLower(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(fiboLowerBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return fiboLowerBuffer[barIndex];
}
//
int CopyFiboLower(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
fiboLowerBuffer,
buffer,
forceClean
//
);
}
//
// ZigZag ...
//
double GetZigZag(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
// Calculate(barIndex);
SpecifiedClean(zigzagBuffer);
//
CopyBuffer(
mHandler,
XFIMA_ZIGZAG_LINE,
barIndex,
1,
zigzagBuffer //
);
//
int count = ArraySize(zigzagBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return zigzagBuffer[barIndex];
}
//
int CopyZigZag(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
// Calculate(start);
SpecifiedClean(zigzagBuffer);
//
CopyBuffer(
mHandler,
XFIMA_ZIGZAG_LINE,
start,
0,
zigzagBuffer //
);
//
// Copy Items ...
return Copy(
0,
count,
zigzagBuffer,
buffer,
forceClean
//
);
}
//
// CYCLES Range ...
//
// SHORT ...
//
// HH ...
//
double GetSHH(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(sHHBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return sHHBuffer[barIndex];
}
//
int CopySHH(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
sHHBuffer,
buffer,
forceClean
//
);
}
//
// LL ...
//
double GetSLL(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(sLLBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return sLLBuffer[barIndex];
}
//
int CopySLL(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
sLLBuffer,
buffer,
forceClean
//
);
}
//
// MEDIUM ...
//
// HH ...
//
double GetMHH(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(mHHBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return mHHBuffer[barIndex];
}
//
int CopyMHH(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
mHHBuffer,
buffer,
forceClean
//
);
}
//
// LL ...
//
double GetMLL(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(mLLBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return mLLBuffer[barIndex];
}
//
int CopyMLL(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
mLLBuffer,
buffer,
forceClean
//
);
}
//
// LONG ...
//
// HH ...
//
double GetLHH(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(lHHBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return lHHBuffer[barIndex];
}
//
int CopyLHH(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
lHHBuffer,
buffer,
forceClean
//
);
}
//
// LL ...
//
double GetLLL(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(lLLBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return lLLBuffer[barIndex];
}
//
int CopyLLL(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
lLLBuffer,
buffer,
forceClean
//
);
}
//
// HIND ...
//
// HH ...
//
double GetHHH(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(hHHBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return hHHBuffer[barIndex];
}
//
int CopyHHH(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
hHHBuffer,
buffer,
forceClean
//
);
}
//
// LL ...
//
double GetHLL(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(hLLBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return hLLBuffer[barIndex];
}
//
int CopyHLL(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
hLLBuffer,
buffer,
forceClean
//
);
}
//
// XHK ...
//
// XHK Open ...
//
double GetHKOpen(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(hkOpenBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return hkOpenBuffer[barIndex];
}
//
int CopyHKOpen(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
hkOpenBuffer,
buffer,
forceClean
//
);
}
//
// XHK High ...
//
double GetHKHigh(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(hkHighBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return hkHighBuffer[barIndex];
}
//
int CopyHKHigh(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
hkHighBuffer,
buffer,
forceClean
//
);
}
//
// XHK Low ...
//
double GetHKLow(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(hkLowBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return hkLowBuffer[barIndex];
}
//
int CopyHKLow(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
hkLowBuffer,
buffer,
forceClean
//
);
}
//
// XHK Close ...
//
double GetHKClose(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(hkCloseBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return hkCloseBuffer[barIndex];
}
//
int CopyHKClose(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
hkCloseBuffer,
buffer,
forceClean
//
);
}
//
// XHK Color ...
//
double GetHKColor(
int barIndex // Bar Index
)
{
//
if (barIndex < 0)
{
barIndex = 0;
}
//
Calculate(barIndex);
//
int count = ArraySize(hkColorBuffer);
if (barIndex >= count)
{
barIndex = count - 1;
}
//
return hkColorBuffer[barIndex];
}
//
int CopyHKColor(
int start, // Start
int count, // Number of Items for read
double &buffer[], // Dest Buffer
bool forceClean = true // Force To Clean buffer
)
{
//
// Update Calculations ...
Calculate(start);
//
// Copy Items ...
return Copy(
0,
count,
hkColorBuffer,
buffer,
forceClean
//
);
}
//
// Protected ...
protected:
//
// Private ...
private:
//
// Props ...
XFIMAInputs mInputs; // Inputs ...
//
// Buffers ...
// Define in Public ...
//
void Calculate(
int barIndex = 0,
int maxRequiredBars = 100 //
)
{
//
// Buffers ...
if (barIndex < 0)
{
barIndex = 0;
}
//
CopyBuffer(
mHandler,
XFIMA_MA_FAST_LINE,
barIndex,
maxRequiredBars,
maFastBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_MA_FAST_COLOR_LINE,
barIndex,
maxRequiredBars,
maFastColorBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_MA_FAST_STATE_LINE,
barIndex,
maxRequiredBars,
maFastStateBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_MA_SLOW_LINE,
barIndex,
maxRequiredBars,
maSlowBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_MA_SLOW_COLOR_LINE,
barIndex,
maxRequiredBars,
maSlowColorBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_MA_SLOW_STATE_LINE,
barIndex,
maxRequiredBars,
maSlowStateBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_MA_BAND_UPPER_LINE,
barIndex,
maxRequiredBars,
maBandUpperBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_MA_BAND_LOWER_LINE,
barIndex,
maxRequiredBars,
maBandLowerBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_SAR_LINE,
barIndex,
maxRequiredBars,
sarBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_SAR_COLOR_LINE,
barIndex,
maxRequiredBars,
sarColorBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_SAR_STATE_LINE,
barIndex,
maxRequiredBars,
sarStateBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_PEAK_LINE,
barIndex,
maxRequiredBars,
peakBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_VALE_LINE,
barIndex,
maxRequiredBars,
valeBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_FIBO_UPPER_LINE,
barIndex,
maxRequiredBars,
fiboUpperBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_FIBO_MIDDLE_LINE,
barIndex,
maxRequiredBars,
fiboMiddleBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_FIBO_LOWER_LINE,
barIndex,
maxRequiredBars,
fiboLowerBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_ZIGZAG_LINE,
barIndex,
maxRequiredBars,
zigzagBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_SC_HH_LINE,
barIndex,
maxRequiredBars,
sHHBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_SC_LL_LINE,
barIndex,
maxRequiredBars,
sLLBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_MC_HH_LINE,
barIndex,
maxRequiredBars,
mHHBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_MC_LL_LINE,
barIndex,
maxRequiredBars,
mLLBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_LC_HH_LINE,
barIndex,
maxRequiredBars,
lHHBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_LC_LL_LINE,
barIndex,
maxRequiredBars,
lLLBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_HC_HH_LINE,
barIndex,
maxRequiredBars,
hHHBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_HC_LL_LINE,
barIndex,
maxRequiredBars,
hLLBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_ZIGZAG_HIGHS_LINE,
barIndex,
maxRequiredBars,
highsBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_ZIGZAG_HIGHS_TIME_LINE,
barIndex,
maxRequiredBars,
highsTimeBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_ZIGZAG_LOWS_LINE,
barIndex,
maxRequiredBars,
lowsBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_ZIGZAG_LOWS_TIME_LINE,
barIndex,
maxRequiredBars,
lowsTimeBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_HK_OPEN_LINE,
barIndex,
maxRequiredBars,
hkOpenBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_HK_HIGH_LINE,
barIndex,
maxRequiredBars,
hkHighBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_HK_LOW_LINE,
barIndex,
maxRequiredBars,
hkLowBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_HK_CLOSE_LINE,
barIndex,
maxRequiredBars,
hkCloseBuffer //
);
//
CopyBuffer(
mHandler,
XFIMA_HK_COLOR_LINE,
barIndex,
maxRequiredBars,
hkColorBuffer //
);
}
//
void Cleanup(
int maxAllowed = 100 //
)
{
//
CleanupArray(
maFastBuffer,
maxAllowed //
);
//
CleanupArray(
maFastColorBuffer,
maxAllowed //
);
//
CleanupArray(
maFastStateBuffer,
maxAllowed //
);
//
CleanupArray(
maSlowBuffer,
maxAllowed //
);
//
CleanupArray(
maSlowColorBuffer,
maxAllowed //
);
//
CleanupArray(
maSlowStateBuffer,
maxAllowed //
);
//
CleanupArray(
maBandUpperBuffer,
maxAllowed //
);
//
CleanupArray(
maBandLowerBuffer,
maxAllowed //
);
//
CleanupArray(
sarBuffer,
maxAllowed //
);
//
CleanupArray(
sarColorBuffer,
maxAllowed //
);
//
CleanupArray(
sarStateBuffer,
maxAllowed //
);
//
CleanupArray(
peakBuffer,
maxAllowed //
);
//
CleanupArray(
valeBuffer,
maxAllowed //
);
//
CleanupArray(
fiboUpperBuffer,
maxAllowed //
);
//
CleanupArray(
fiboMiddleBuffer,
maxAllowed //
);
//
CleanupArray(
fiboLowerBuffer,
maxAllowed //
);
//
CleanupArray(
zigzagBuffer,
maxAllowed //
);
//
CleanupArray(
sHHBuffer,
maxAllowed //
);
//
CleanupArray(
sLLBuffer,
maxAllowed //
);
//
CleanupArray(
mHHBuffer,
maxAllowed //
);
//
CleanupArray(
mLLBuffer,
maxAllowed //
);
//
CleanupArray(
lHHBuffer,
maxAllowed //
);
//
CleanupArray(
lLLBuffer,
maxAllowed //
);
//
CleanupArray(
hHHBuffer,
maxAllowed //
);
//
CleanupArray(
hLLBuffer,
maxAllowed //
);
//
CleanupArray(
highsBuffer,
maxAllowed //
);
//
CleanupArray(
highsTimeBuffer,
maxAllowed //
);
//
CleanupArray(
lowsBuffer,
maxAllowed //
);
//
CleanupArray(
lowsTimeBuffer,
maxAllowed //
);
//
CleanupArray(
hkOpenBuffer,
maxAllowed //
);
//
CleanupArray(
hkHighBuffer,
maxAllowed //
);
//
CleanupArray(
hkLowBuffer,
maxAllowed //
);
//
CleanupArray(
hkCloseBuffer,
maxAllowed //
);
//
CleanupArray(
hkColorBuffer,
maxAllowed //
);
}
//
// XHK Helper ...
//
int ReadHKBars(
double &open[],
double &high[],
double &low[],
double &close[],
int barIndex = 0,
int count = 1 //
)
{
//
int result = 0;
//
// Prepare ...
SpecifiedClean(low);
SpecifiedClean(open);
SpecifiedClean(high);
SpecifiedClean(close);
//
// Normalize ...
count = NormalizeInt(count, 1);
barIndex = NormalizeInt(barIndex, 0);
//
// Validate ...
if (mHandler == INVALID_HANDLE)
{
return result;
}
//
// Open ...
CopyBuffer(
mHandler,
XFIMA_HK_OPEN_LINE,
barIndex,
count,
open //
);
//
// High ...
CopyBuffer(
mHandler,
XFIMA_HK_HIGH_LINE,
barIndex,
count,
high //
);
//
// Low ...
CopyBuffer(
mHandler,
XFIMA_HK_LOW_LINE,
barIndex,
count,
low //
);
//
// Close ...
CopyBuffer(
mHandler,
XFIMA_HK_CLOSE_LINE,
barIndex,
count,
close //
);
//
ArraySetAsSeries(low, true);
ArraySetAsSeries(open, true);
ArraySetAsSeries(high, true);
ArraySetAsSeries(close, true);
//
// Min Number of Array Sizes ...
result = MathMin(ArraySize(open), ArraySize(high));
result = MathMin(result, ArraySize(close));
result = MathMin(result, ArraySize(low));
//
return result;
}
/**
* Validate HK Zone ...
*
* @param zone: XBoxZone, reference to Specified Zone ...
* @param validationLength: int, Validation Length of Zones ...
* @param breakValidLength: int, Break Validation Length of Zones ...
* @param validateFakeBreakes: bool, Validation Fake Breaked Zones ...
*
* @return ( bool )
*/
bool ValidateHKZone(
XBoxZone &zone,
int validationLength = 1,
int breakValidLength = 3,
bool validateFakeBreakes = true //
)
{
//
bool result = false;
//
// Normalize ...
validationLength = NormalizeInt(validationLength, 1);
breakValidLength = NormalizeInt(breakValidLength, 2);
//
// Validate ...
result = zone.IsValid();
if (!result)
{
return result;
}
//
// Requirements ...
double low[];
double open[];
double high[];
int count = 0;
double close[];
//
int start = zone.FromIndex() + 1;
int end = start + validationLength;
//
// Validate Before ...
for (int i = start; i < end; i++)
{
//
// Reading HK ...
count = ReadHKBars(
open,
high,
low,
close,
i,
1 //
);
result = IsValidSize(count);
if (!result)
{
break;
}
//
result = zone.IsBullish()
? low[0] > zone.lower
: high[0] < zone.upper;
if (!result)
{
break;
}
}
//
// Validating After ...
if (result)
{
//
start = zone.ToIndex() + 1;
count = zone.FromIndex() - start;
end = start + count;
for (int i = start; i < end; i++)
{
//
// Reading HK ...
count = ReadHKBars(
open,
high,
low,
close,
i,
1 //
);
result = IsValidSize(count);
if (!result)
{
break;
}
//
result = zone.IsBullish()
? low[0] > zone.lower
: high[0] < zone.upper;
if (!result)
{
//
// Check For Fake Breake ...
if (validateFakeBreakes && breakValidLength > 0)
{
//
result = i - 1 >= 0;
if (result)
{
//
for (int j = i - 1; j >= zone.ToIndex(); j--)
{
//
// Reading HK ...
count = ReadHKBars(
open,
high,
low,
close,
j,
1 //
);
result = IsValidSize(count);
if (!result)
{
break;
}
//
result = zone.IsBullish()
? close[0] > zone.upper
: close[0] < zone.lower;
if (result)
{
//
result = MathAbs(j - i) <= breakValidLength;
if (result)
{
break;
}
}
}
}
}
//
if (!result)
{
break;
}
}
}
}
//
// Cleanup Resource ...
SpecifiedClean(low);
SpecifiedClean(open);
SpecifiedClean(high);
SpecifiedClean(close);
//
return result;
}
//
int ReadMAValues(
double &fast[],
double &slow[],
double &upper[],
double &lower[],
int barIndex = 0,
int count = 0 //
)
{
//
int result = 0;
//
// Prepare ...
SpecifiedClean(fast);
SpecifiedClean(slow);
SpecifiedClean(upper);
SpecifiedClean(lower);
//
// Normalize ...
count = NormalizeInt(count, 1);
barIndex = NormalizeInt(barIndex, 0);
//
// Validate ...
if (mHandler == INVALID_HANDLE)
{
return result;
}
//
CopyBuffer(
mHandler,
XFIMA_MA_FAST_LINE,
barIndex,
count,
fast //
);
//
CopyBuffer(
mHandler,
XFIMA_MA_SLOW_LINE,
barIndex,
count,
slow //
);
//
CopyBuffer(
mHandler,
XFIMA_MA_BAND_UPPER_LINE,
barIndex,
count,
upper //
);
//
CopyBuffer(
mHandler,
XFIMA_MA_BAND_LOWER_LINE,
barIndex,
count,
lower //
);
//
ArraySetAsSeries(fast, true);
ArraySetAsSeries(slow, true);
ArraySetAsSeries(upper, true);
ArraySetAsSeries(lower, true);
//
result = MathMin(ArraySize(fast), ArraySize(slow));
result = MathMin(result, ArraySize(upper));
result = MathMin(result, ArraySize(lower));
//
return result;
}
//
};
//
Reference in New Issue View Git Blame Copy Permalink