1076 lines
21 KiB
Plaintext
1076 lines
21 KiB
Plaintext
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 XCHLH Oscillator Helper for Signal Providers
|
|
// ---------------------------------------------------------------------
|
|
//
|
|
//
|
|
// 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
|
|
|
|
//
|
|
#include "..\Libraries\x-saherelm.log.lib.mq5"
|
|
#include "..\Libraries\x-saherelm.common.lib.mq5"
|
|
#include "x-saherelm.xmap.provider.inputs.lib.mq5"
|
|
|
|
//
|
|
// START Enum Definitions ...
|
|
//
|
|
//
|
|
// XCHLH Hot States ...
|
|
enum ENUM_X_XCHLH_HOT_STATES
|
|
{
|
|
X_XCHLH_HOT_HH = 1,
|
|
X_XCHLH_NEUTURAL = 0,
|
|
X_XCHLH_HOT_LL = -1,
|
|
};
|
|
|
|
//
|
|
// XCHLH Buffer Lines ...
|
|
enum ENUM_X_XCHLH_BUFFER_LINES {
|
|
X_XCHLH_LC_HH_LINE = 0,
|
|
X_XCHLH_LC_LL_LINE = 1,
|
|
X_XCHLH_MC_HH_LINE = 2,
|
|
X_XCHLH_MC_LL_LINE = 3,
|
|
X_XCHLH_SC_HH_LINE = 4,
|
|
X_XCHLH_SC_LL_LINE = 5,
|
|
X_XCHLH_HOT_STATE_LINE = 6,
|
|
};
|
|
//
|
|
// END Enum Definitions ...
|
|
//
|
|
|
|
//
|
|
// START Inputs ...
|
|
//
|
|
input group "XCHLH Indicator";
|
|
|
|
//
|
|
// Common ...
|
|
input group "XCHLH Hot Areas";
|
|
input bool xCHLHDrawHotAreas = false; // Draw Hot Areas Symbol
|
|
input uchar xCHLHHotHHArrowCode = 234; // Hot HH Arrow Code
|
|
input color xCHLHHotHHArrowColor = clrAqua; // Hot HH Arrow Color
|
|
input uchar xCHLHHotLLArrowCode = 233; // Hot LL Arrow Code
|
|
input color xCHLHHotLLArrowColor = clrFuchsia; // Hot LL Arrow Color
|
|
|
|
//
|
|
// LC Inputs ...
|
|
input group "XCHLH Long Cycle";
|
|
input group "XCHLH LC Market";
|
|
input int xCHLHLcLength = 288; // Length
|
|
input double xCHLHLcThresholdInPips = 0.3; // Threshold In Pips
|
|
input ENUM_SERIESMODE xCHLHLcHHMode = MODE_HIGH; // Highest High Calculation Method
|
|
input ENUM_SERIESMODE xCHLHLcLLMode = MODE_LOW; // Lowest Low Calculation Method
|
|
input group "XCHLH LC Style";
|
|
input int xCHLHLcDrawWidth = 1; // Draw Width
|
|
input ENUM_DRAW_TYPE xCHLHLcDrawType = DRAW_LINE; // Draw Type
|
|
input ENUM_LINE_STYLE xCHLHLcDrawStyle = STYLE_DOT; // Draw Style
|
|
input color xCHLHLcHHColor = clrAqua; // Highest High Color
|
|
input color xCHLHLcLLColor = clrFuchsia; // Lowest Low Color
|
|
input group "XCHLH LC Drawings";
|
|
input bool xCHLHLcDrawHH = true; // Draw Highest High
|
|
input bool xCHLHLcDrawLL = true; // Draw Lowest Low
|
|
|
|
//
|
|
// MC Inputs ...
|
|
input group "XCHLH Medium Cycle";
|
|
input group "XCHLH MC Market";
|
|
input int xCHLHMcLength = 72; // Length
|
|
input double xCHLHMcThresholdInPips = 0.3; // Threshold In Pips
|
|
input ENUM_SERIESMODE xCHLHMcHHMode = MODE_HIGH; // Highest High Calculation Method
|
|
input ENUM_SERIESMODE xCHLHMcLLMode = MODE_LOW; // Lowest Low Calculation Method
|
|
input group "XCHLH MC Style";
|
|
input int xCHLHMcDrawWidth = 1; // Draw Width
|
|
input ENUM_DRAW_TYPE xCHLHMcDrawType = DRAW_LINE; // Draw Type
|
|
input ENUM_LINE_STYLE xCHLHMcDrawStyle = STYLE_DOT; // Draw Style
|
|
input color xCHLHMcHHColor = clrLime; // Highest High Color
|
|
input color xCHLHMcLLColor = clrRed; // Lowest Low Color
|
|
input group "XCHLH MC Drawings";
|
|
input bool xCHLHMcDrawHH = true; // Draw Highest High
|
|
input bool xCHLHMcDrawLL = true; // Draw Lowest Low
|
|
|
|
//
|
|
// SC Inputs ...
|
|
input group "XCHLH Short Cycle";
|
|
input group "XCHLH SC Market";
|
|
input int xCHLHScLength = 7; // Length
|
|
input double xCHLHScThresholdInPips = 0.3; // Threshold In Pips
|
|
input ENUM_SERIESMODE xCHLHScHHMode = MODE_HIGH; // Highest High Calculation Method
|
|
input ENUM_SERIESMODE xCHLHScLLMode = MODE_LOW; // Lowest Low Calculation Method
|
|
input group "XCHLH SC Style";
|
|
input int xCHLHScDrawWidth = 1; // Draw Width
|
|
input ENUM_DRAW_TYPE xCHLHScDrawType = DRAW_LINE; // Draw Type
|
|
input ENUM_LINE_STYLE xCHLHScDrawStyle = STYLE_DOT; // Draw Style
|
|
input color xCHLHScHHColor = clrLightBlue; // Highest High Color
|
|
input color xCHLHScLLColor = clrLightSalmon; // Lowest Low Color
|
|
input group "XCHLH SC Drawings";
|
|
input bool xCHLHScDrawHH = true; // Draw Highest High
|
|
input bool xCHLHScDrawLL = true; // Draw Lowest Low
|
|
//
|
|
// END Inputs ...
|
|
//
|
|
|
|
//
|
|
// START Definitions ...
|
|
//
|
|
int xCHLHHandler = INVALID_HANDLE;
|
|
double xCHLHLcHHBuffer[];
|
|
double xCHLHLcLLBuffer[];
|
|
double xCHLHMcHHBuffer[];
|
|
double xCHLHMcLLBuffer[];
|
|
double xCHLHScHHBuffer[];
|
|
double xCHLHScLLBuffer[];
|
|
double xCHLHHotStateBuffer[];
|
|
//
|
|
// END Definitions ...
|
|
//
|
|
|
|
//
|
|
// START Handler Functions ...
|
|
//
|
|
//
|
|
// Init Indicators ...
|
|
bool XCHLHInitHandlers()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Initialize Indicator/Oscillator Handlers ...
|
|
ResetLastError();
|
|
|
|
//
|
|
// XCHLH Handler ...
|
|
ArraySetAsSeries(xCHLHLcHHBuffer, true);
|
|
ArraySetAsSeries(xCHLHLcLLBuffer, true);
|
|
ArraySetAsSeries(xCHLHMcHHBuffer, true);
|
|
ArraySetAsSeries(xCHLHMcLLBuffer, true);
|
|
ArraySetAsSeries(xCHLHScHHBuffer, true);
|
|
ArraySetAsSeries(xCHLHScLLBuffer, true);
|
|
ArraySetAsSeries(xCHLHHotStateBuffer, true);
|
|
xCHLHHandler = iCustom(
|
|
_Symbol,
|
|
_Period,
|
|
"x-saherelm.xchlh.indicator",
|
|
//
|
|
// Inputs ...
|
|
//
|
|
// Commons ...
|
|
"",
|
|
xCHLHDrawHotAreas,
|
|
xCHLHHotHHArrowCode,
|
|
xCHLHHotHHArrowColor,
|
|
xCHLHHotLLArrowCode,
|
|
xCHLHHotLLArrowColor,
|
|
//
|
|
// LC ...
|
|
"",
|
|
"",
|
|
xCHLHLcLength,
|
|
xCHLHLcThresholdInPips,
|
|
xCHLHLcHHMode,
|
|
xCHLHLcLLMode,
|
|
"",
|
|
xCHLHLcDrawWidth,
|
|
xCHLHLcDrawType,
|
|
xCHLHLcDrawStyle,
|
|
xCHLHLcHHColor,
|
|
xCHLHLcLLColor,
|
|
"",
|
|
xCHLHLcDrawHH,
|
|
xCHLHLcDrawLL,
|
|
//
|
|
// MC ...
|
|
"",
|
|
"",
|
|
xCHLHMcLength,
|
|
xCHLHMcThresholdInPips,
|
|
xCHLHMcHHMode,
|
|
xCHLHMcLLMode,
|
|
"",
|
|
xCHLHMcDrawWidth,
|
|
xCHLHMcDrawType,
|
|
xCHLHMcDrawStyle,
|
|
xCHLHMcHHColor,
|
|
xCHLHMcLLColor,
|
|
"",
|
|
xCHLHMcDrawHH,
|
|
xCHLHMcDrawLL,
|
|
//
|
|
// SC ...
|
|
"",
|
|
"",
|
|
xCHLHScLength,
|
|
xCHLHScThresholdInPips,
|
|
xCHLHScHHMode,
|
|
xCHLHScLLMode,
|
|
"",
|
|
xCHLHScDrawWidth,
|
|
xCHLHScDrawType,
|
|
xCHLHScDrawStyle,
|
|
xCHLHScHHColor,
|
|
xCHLHScLLColor,
|
|
"",
|
|
xCHLHScDrawHH,
|
|
xCHLHScDrawLL);
|
|
if (xCHLHHandler == INVALID_HANDLE)
|
|
{
|
|
//
|
|
LogMessage("failed to Initialize XCHLH Indicator: " + (string)GetLastError());
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = true;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Release Indicators ...
|
|
void XCHLHReleaseHandlers()
|
|
{
|
|
IndicatorRelease(xCHLHHandler);
|
|
}
|
|
|
|
//
|
|
// Handle Reading Buffers ...
|
|
void XCHLHReadBuffers()
|
|
{
|
|
//
|
|
// XCHLH LC HH Buffer ...
|
|
CopyBuffer(
|
|
xCHLHHandler,
|
|
X_XCHLH_LC_HH_LINE,
|
|
0,
|
|
xMAPNumberOfItemsPerTick,
|
|
xCHLHLcHHBuffer);
|
|
|
|
//
|
|
// XCHLH LC LL Buffer ...
|
|
CopyBuffer(
|
|
xCHLHHandler,
|
|
X_XCHLH_LC_LL_LINE,
|
|
0,
|
|
xMAPNumberOfItemsPerTick,
|
|
xCHLHLcLLBuffer);
|
|
|
|
//
|
|
// XCHLH MC HH Buffer ...
|
|
CopyBuffer(
|
|
xCHLHHandler,
|
|
X_XCHLH_MC_HH_LINE,
|
|
0,
|
|
xMAPNumberOfItemsPerTick,
|
|
xCHLHMcHHBuffer);
|
|
|
|
//
|
|
// XCHLH MC LL Buffer ...
|
|
CopyBuffer(
|
|
xCHLHHandler,
|
|
X_XCHLH_MC_LL_LINE,
|
|
0,
|
|
xMAPNumberOfItemsPerTick,
|
|
xCHLHMcLLBuffer);
|
|
|
|
//
|
|
// XCHLH SC HH Buffer ...
|
|
CopyBuffer(
|
|
xCHLHHandler,
|
|
X_XCHLH_SC_HH_LINE,
|
|
0,
|
|
xMAPNumberOfItemsPerTick,
|
|
xCHLHScHHBuffer);
|
|
|
|
//
|
|
// XCHLH SC LL Buffer ...
|
|
CopyBuffer(
|
|
xCHLHHandler,
|
|
X_XCHLH_SC_LL_LINE,
|
|
0,
|
|
xMAPNumberOfItemsPerTick,
|
|
xCHLHScLLBuffer);
|
|
|
|
//
|
|
// XCHLH Hot State Buffer ...
|
|
CopyBuffer(
|
|
xCHLHHandler,
|
|
X_XCHLH_HOT_STATE_LINE,
|
|
0,
|
|
xMAPNumberOfItemsPerTick,
|
|
xCHLHHotStateBuffer);
|
|
}
|
|
//
|
|
// END Handler Funcions ...
|
|
//
|
|
|
|
//
|
|
// START XCHLH Custom Functions ...
|
|
//
|
|
//
|
|
// Find Peak based On this Indicator ...
|
|
bool XCHLHIsPeak(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Find Vale based On this Indicator ...
|
|
bool XCHLHIsVale(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check is Same HH's in LC and MC ...
|
|
bool XCHLHIsSameLCMCHH(
|
|
int bar_index // sepcified Bar Index
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
if (bar_index <= 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result =
|
|
xCHLHLcHHBuffer[bar_index] == xCHLHMcHHBuffer[bar_index];
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check is Same LL's in LC and MC ...
|
|
bool XCHLHIsSameLCMCLL(
|
|
int bar_index // sepcified Bar Index
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
if (bar_index <= 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result =
|
|
xCHLHLcLLBuffer[bar_index] == xCHLHMcLLBuffer[bar_index];
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check is Same HH's in MC and SC ...
|
|
bool XCHLHIsSameMCSCHH(
|
|
int bar_index // sepcified Bar Index
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
if (bar_index <= 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result =
|
|
xCHLHMcHHBuffer[bar_index] == xCHLHScHHBuffer[bar_index];
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check is Same LL's in MC and SC ...
|
|
bool XCHLHIsSameMCSCLL(
|
|
int bar_index // sepcified Bar Index
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
if (bar_index <= 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result =
|
|
xCHLHMcLLBuffer[bar_index] == xCHLHScLLBuffer[bar_index];
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Loop Back Same LC and MC HH ...
|
|
bool XCHLHIsLCMCHHSameInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Loopbak Loop for Detect Sames ...
|
|
for (int i = 1; i <= loopback && !result; i++)
|
|
{
|
|
//
|
|
result = xCHLHLcHHBuffer[i] == xCHLHMcHHBuffer[i];
|
|
if (result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Loop Back Same LC and MC LL ...
|
|
bool XCHLHIsLCMCLLSameInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// Loopbak Loop for Detect Sames ...
|
|
for (int i = 1; i <= loopback && !result; i++)
|
|
{
|
|
//
|
|
result = xCHLHLcLLBuffer[i] == xCHLHMcLLBuffer[i];
|
|
if (result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Loop Back Same MC and SC HH ...
|
|
bool XCHLHIsMCSCHHSameInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// Loopbak Loop for Detect Sames ...
|
|
for (int i = 1; i <= loopback && !result; i++)
|
|
{
|
|
//
|
|
result = xCHLHLcHHBuffer[i] == xCHLHMcHHBuffer[i];
|
|
if (result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detect Loop Back Same MC and SC LL ...
|
|
bool XCHLHIsMCSCLLSameInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// Loopbak Loop for Detect Sames ...
|
|
for (int i = 1; i <= loopback && !result; i++)
|
|
{
|
|
//
|
|
result = xCHLHLcLLBuffer[i] == xCHLHMcLLBuffer[i];
|
|
if (result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Get LC HH - LL value ...
|
|
double XCHLHGetLCDiff(
|
|
int bar_index // sepcified Bar Index
|
|
)
|
|
{
|
|
//
|
|
double result = 0;
|
|
|
|
//
|
|
result =
|
|
xCHLHLcHHBuffer[bar_index] - xCHLHLcLLBuffer[bar_index];
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Get MC HH - LL value ...
|
|
double XCHLHGetMCDiff(
|
|
int bar_index // sepcified Bar Index
|
|
)
|
|
{
|
|
//
|
|
double result = 0;
|
|
|
|
//
|
|
result =
|
|
xCHLHMcHHBuffer[bar_index] - xCHLHMcLLBuffer[bar_index];
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Get SC HH - LL value ...
|
|
double XCHLHGetSCDiff(
|
|
int bar_index // sepcified Bar Index
|
|
)
|
|
{
|
|
//
|
|
double result = 0;
|
|
|
|
//
|
|
result =
|
|
xCHLHScHHBuffer[bar_index] - xCHLHScLLBuffer[bar_index];
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check LC HH is Going Up or not ...
|
|
bool XCHLHIsLCHHInreasedInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0 || ArraySize(xCHLHLcHHBuffer) < loopback)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double value1 = xCHLHLcHHBuffer[1];
|
|
double valueLast = xCHLHLcHHBuffer[loopback - 1];
|
|
result = value1 > valueLast;
|
|
for (int i = 2; i < loopback; i++)
|
|
{
|
|
//
|
|
double valuei = xCHLHLcHHBuffer[i];
|
|
bool isResult = value1 >= valuei;
|
|
|
|
//
|
|
result = result && isResult;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check LC LL is Going Up or not ...
|
|
bool XCHLHIsLCLLInreasedInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0 || ArraySize(xCHLHLcLLBuffer) < loopback)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double value1 = xCHLHLcLLBuffer[1];
|
|
double valueLast = xCHLHLcLLBuffer[loopback - 1];
|
|
result = value1 > valueLast;
|
|
for (int i = 2; i < loopback; i++)
|
|
{
|
|
//
|
|
double valuei = xCHLHLcLLBuffer[i];
|
|
bool isResult = value1 >= valuei;
|
|
|
|
//
|
|
result = result && isResult;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check LC HH is Going Down or not ...
|
|
bool XCHLHIsLCHHDecreasedInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0 || ArraySize(xCHLHLcHHBuffer) < loopback)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double value1 = xCHLHLcHHBuffer[1];
|
|
double valueLast = xCHLHLcHHBuffer[loopback - 1];
|
|
result = value1 < valueLast;
|
|
for (int i = 2; i < loopback; i++)
|
|
{
|
|
//
|
|
double valuei = xCHLHLcHHBuffer[i];
|
|
bool isResult = value1 <= valuei;
|
|
|
|
//
|
|
result = result && isResult;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check LC LL is Going Down or not ...
|
|
bool XCHLHIsLCLLDecreasedInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0 || ArraySize(xCHLHLcLLBuffer) < loopback)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double value1 = xCHLHLcLLBuffer[1];
|
|
double valueLast = xCHLHLcLLBuffer[loopback - 1];
|
|
result = value1 < valueLast;
|
|
for (int i = 2; i < loopback; i++)
|
|
{
|
|
//
|
|
double valuei = xCHLHLcLLBuffer[i];
|
|
bool isResult = value1 <= valuei;
|
|
|
|
//
|
|
result = result && isResult;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check MC HH is Going Up or not ...
|
|
bool XCHLHIsMCHHInreasedInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0 || ArraySize(xCHLHMcHHBuffer) < loopback)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double value1 = xCHLHMcHHBuffer[1];
|
|
double valueLast = xCHLHMcHHBuffer[loopback - 1];
|
|
result = value1 > valueLast;
|
|
for (int i = 2; i < loopback; i++)
|
|
{
|
|
//
|
|
double valuei = xCHLHMcHHBuffer[i];
|
|
bool isResult = value1 >= valuei;
|
|
|
|
//
|
|
result = result && isResult;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check MC LL is Going Up or not ...
|
|
bool XCHLHIsMCLLInreasedInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0 || ArraySize(xCHLHMcLLBuffer) < loopback)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double value1 = xCHLHMcLLBuffer[1];
|
|
double valueLast = xCHLHLcLLBuffer[loopback - 1];
|
|
result = value1 > valueLast;
|
|
for (int i = 2; i < loopback; i++)
|
|
{
|
|
//
|
|
double valuei = xCHLHMcLLBuffer[i];
|
|
bool isResult = value1 >= valuei;
|
|
|
|
//
|
|
result = result && isResult;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check MC HH is Going Down or not ...
|
|
bool XCHLHIsMCHHDecreasedInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0 || ArraySize(xCHLHMcHHBuffer) < loopback)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double value1 = xCHLHMcHHBuffer[1];
|
|
double valueLast = xCHLHMcHHBuffer[loopback - 1];
|
|
result = value1 < valueLast;
|
|
for (int i = 2; i < loopback; i++)
|
|
{
|
|
//
|
|
double valuei = xCHLHMcHHBuffer[i];
|
|
bool isResult = value1 <= valuei;
|
|
|
|
//
|
|
result = result && isResult;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check MC LL is Going Down or not ...
|
|
bool XCHLHIsMCLLDecreasedInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0 || ArraySize(xCHLHMcLLBuffer) < loopback)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double value1 = xCHLHMcLLBuffer[1];
|
|
double valueLast = xCHLHMcLLBuffer[loopback - 1];
|
|
result = value1 < valueLast;
|
|
for (int i = 2; i < loopback; i++)
|
|
{
|
|
//
|
|
double valuei = xCHLHMcLLBuffer[i];
|
|
bool isResult = value1 <= valuei;
|
|
|
|
//
|
|
result = result && isResult;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check SC HH is Going Up or not ...
|
|
bool XCHLHIsSCHHInreasedInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0 || ArraySize(xCHLHScHHBuffer) < loopback)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double value1 = xCHLHScHHBuffer[1];
|
|
double valueLast = xCHLHScHHBuffer[loopback - 1];
|
|
result = value1 > valueLast;
|
|
for (int i = 2; i < loopback; i++)
|
|
{
|
|
//
|
|
double valuei = xCHLHScHHBuffer[i];
|
|
bool isResult = value1 >= valuei;
|
|
|
|
//
|
|
result = result && isResult;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check SC LL is Going Up or not ...
|
|
bool XCHLHIsSCLLInreasedInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0 || ArraySize(xCHLHScLLBuffer) < loopback)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double value1 = xCHLHScLLBuffer[1];
|
|
double valueLast = xCHLHScLLBuffer[loopback - 1];
|
|
result = value1 > valueLast;
|
|
for (int i = 2; i < loopback; i++)
|
|
{
|
|
//
|
|
double valuei = xCHLHScLLBuffer[i];
|
|
bool isResult = value1 >= valuei;
|
|
|
|
//
|
|
result = result && isResult;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check SC HH is Going Down or not ...
|
|
bool XCHLHIsSCHHDecreasedInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0 || ArraySize(xCHLHScHHBuffer) < loopback)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double value1 = xCHLHScHHBuffer[1];
|
|
double valueLast = xCHLHScHHBuffer[loopback - 1];
|
|
result = value1 < valueLast;
|
|
for (int i = 2; i < loopback; i++)
|
|
{
|
|
//
|
|
double valuei = xCHLHScHHBuffer[i];
|
|
bool isResult = value1 <= valuei;
|
|
|
|
//
|
|
result = result && isResult;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Check SC LL is Going Down or not ...
|
|
bool XCHLHIsSCLLDecreasedInLoopback(
|
|
int loopback // loopback length
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (loopback <= 0 || ArraySize(xCHLHScLLBuffer) < loopback)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
double value1 = xCHLHScLLBuffer[1];
|
|
double valueLast = xCHLHScLLBuffer[loopback - 1];
|
|
result = value1 < valueLast;
|
|
for (int i = 2; i < loopback; i++)
|
|
{
|
|
//
|
|
double valuei = xCHLHScLLBuffer[i];
|
|
bool isResult = value1 <= valuei;
|
|
|
|
//
|
|
result = result && isResult;
|
|
if (!result)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
//
|
|
// END XCHLH Custom Functions ...
|
|
//
|