2338 lines
47 KiB
Plaintext
2338 lines
47 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// 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"
|
|
|
|
//
|
|
// Definitions ...
|
|
|
|
//
|
|
// Buffers ...
|
|
enum ENUM_XFIMA_BUFFERS
|
|
{
|
|
XFIMA_MA_FAST_LINE = 0,
|
|
XFIMA_MA_FAST_COLOR_LINE = 1,
|
|
XFIMA_MA_FAST_STATE_LINE = 12,
|
|
XFIMA_MA_SLOW_LINE = 2,
|
|
XFIMA_MA_SLOW_COLOR_LINE = 3,
|
|
XFIMA_MA_SLOW_STATE_LINE = 13,
|
|
XFIMA_SAR_LINE = 4,
|
|
XFIMA_SAR_COLOR_LINE = 5,
|
|
XFIMA_SAR_STATE_LINE = 14,
|
|
XFIMA_PEAK_LINE = 6,
|
|
XFIMA_VALE_LINE = 7,
|
|
XFIMA_FINO_UPPER_LINE = 8,
|
|
XFIMA_FINO_MIDDLE_LINE = 9,
|
|
XFIMA_FINO_LOWER_LINE = 10,
|
|
XFIMA_ZIGZAG_LINE = 11,
|
|
XFIMA_ZIGZAG_HIGHS_LINE = 23,
|
|
XFIMA_ZIGZAG_HIGHS_TIME_LINE = 24,
|
|
XFIMA_ZIGZAG_LOWS_LINE = 25,
|
|
XFIMA_ZIGZAG_LOWS_TIME_LINE = 26,
|
|
// 12 Ma Fast State
|
|
// 13 Ma Slow State
|
|
// 14 Sar State
|
|
XFIMA_SC_HH_LINE = 15,
|
|
XFIMA_SC_LL_LINE = 16,
|
|
XFIMA_MC_HH_LINE = 17,
|
|
XFIMA_MC_LL_LINE = 18,
|
|
XFIMA_LC_HH_LINE = 19,
|
|
XFIMA_LC_LL_LINE = 20,
|
|
XFIMA_HC_HH_LINE = 21,
|
|
XFIMA_HC_LL_LINE = 22,
|
|
// 23 ZigZag Highs
|
|
// 24 ZigZag Highs Time
|
|
// 25 ZigZag Lows
|
|
// 26 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 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 showSAR; // Show Sar
|
|
bool showMAFast; // Show MA Fast
|
|
bool showMASlow; // Show MA Slow
|
|
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
|
|
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
|
|
showSAR = true; // Show Sar
|
|
showMAFast = true; // Show MA Fast
|
|
showMASlow = true; // Show MA Slow
|
|
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;
|
|
showSAR = false;
|
|
showMAFast = false;
|
|
showMASlow = false;
|
|
showZigZag = false;
|
|
showFiboZone = false;
|
|
}
|
|
|
|
//
|
|
// Validate ...
|
|
bool IsValid()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
// MA ...
|
|
maFastLength >= 2 &&
|
|
maSlowLength >= 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 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[];
|
|
|
|
//
|
|
// 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(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);
|
|
|
|
//
|
|
// Conditions ...
|
|
|
|
//
|
|
ArraySetAsSeries(bars, true);
|
|
|
|
//
|
|
ArraySetAsSeries(maFastBuffer, true);
|
|
ArraySetAsSeries(maFastColorBuffer, true);
|
|
ArraySetAsSeries(maFastStateBuffer, true);
|
|
ArraySetAsSeries(maSlowBuffer, true);
|
|
ArraySetAsSeries(maSlowColorBuffer, true);
|
|
ArraySetAsSeries(maSlowStateBuffer, 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, true);
|
|
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);
|
|
|
|
//
|
|
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 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[];
|
|
|
|
//
|
|
// 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(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, true);
|
|
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);
|
|
|
|
//
|
|
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.zigzagDepth,
|
|
mInputs.zigzagDeviation,
|
|
mInputs.zigzagBackStep,
|
|
mInputs.zigzagUppersMode,
|
|
mInputs.zigzagLowersMode,
|
|
"", // Presentation ...
|
|
mInputs.showPV,
|
|
mInputs.showSAR,
|
|
mInputs.showMAFast,
|
|
mInputs.showMASlow,
|
|
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 //
|
|
);
|
|
|
|
//
|
|
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 //
|
|
);
|
|
|
|
//
|
|
// Conditions ...
|
|
|
|
//
|
|
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
|
|
//
|
|
);
|
|
}
|
|
|
|
//
|
|
// 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);
|
|
|
|
//
|
|
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);
|
|
|
|
//
|
|
// 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
|
|
//
|
|
);
|
|
}
|
|
|
|
//
|
|
// 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_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_FINO_UPPER_LINE,
|
|
barIndex,
|
|
maxRequiredBars,
|
|
fiboUpperBuffer //
|
|
);
|
|
|
|
//
|
|
CopyBuffer(
|
|
mHandler,
|
|
XFIMA_FINO_MIDDLE_LINE,
|
|
barIndex,
|
|
maxRequiredBars,
|
|
fiboMiddleBuffer //
|
|
);
|
|
|
|
//
|
|
CopyBuffer(
|
|
mHandler,
|
|
XFIMA_FINO_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 //
|
|
);
|
|
}
|
|
|
|
//
|
|
void Cleanup(
|
|
int maxAllowed = 100 //
|
|
)
|
|
{
|
|
//
|
|
CleanupArray(
|
|
maFastBuffer,
|
|
maxAllowed //
|
|
);
|
|
|
|
//
|
|
CleanupArray(
|
|
maFastColorBuffer,
|
|
maxAllowed //
|
|
);
|
|
|
|
//
|
|
CleanupArray(
|
|
maFastStateBuffer,
|
|
maxAllowed //
|
|
);
|
|
|
|
//
|
|
CleanupArray(
|
|
maSlowBuffer,
|
|
maxAllowed //
|
|
);
|
|
|
|
//
|
|
CleanupArray(
|
|
maSlowColorBuffer,
|
|
maxAllowed //
|
|
);
|
|
|
|
//
|
|
CleanupArray(
|
|
maSlowStateBuffer,
|
|
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 //
|
|
);
|
|
}
|
|
};
|
|
|
|
// |