2525 lines
68 KiB
Plaintext
2525 lines
68 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Class Library
|
|
// ----------------------------------------------
|
|
// Name: XSCBaseX5Provider
|
|
// Description: provides all Base Provider
|
|
// requirements For X5 ...
|
|
//
|
|
//
|
|
// 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 "../Helpers/x-saherelm.xct.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xcc.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xtm.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xama.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xlh.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xtd.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xfi.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xts.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xrsi.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xobd.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xchlh.helper.mq5"
|
|
#include "../Helpers/x-saherelm.xchma.helper.mq5"
|
|
|
|
//
|
|
#include "../Classes/x-saherelm.xprovider.class.mq5"
|
|
|
|
//
|
|
// Definitions ...
|
|
|
|
//
|
|
enum ENUM_X5_SIGNAL_PROVIDERS
|
|
{
|
|
//
|
|
// XSP Expert Support Mechanism ...
|
|
XSP,
|
|
//
|
|
// XTD ...
|
|
XTD,
|
|
//
|
|
// XTAM ...
|
|
XTAM,
|
|
//
|
|
// XSI ...
|
|
XSI,
|
|
//
|
|
// XTSFI ...
|
|
XTSFI,
|
|
//
|
|
// XOBDLH ...
|
|
XOBDLH,
|
|
//
|
|
// XCHMACC ...
|
|
XCHMACC,
|
|
//
|
|
// XCHMACMN ...
|
|
XCHMAMN,
|
|
//
|
|
// XCHMACMX ...
|
|
XCHMAMX,
|
|
};
|
|
|
|
//
|
|
// X5 Provider Inputs ...
|
|
class X5ProviderInputs : public XSCBaseProviderInpts
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
// Props ...
|
|
XTSInputs tsInputs;
|
|
XTMInputs tmInputs;
|
|
XLHInputs lhInputs;
|
|
XTDInputs tdInputs;
|
|
XFIInputs fiInputs;
|
|
XCTInputs ctInputs;
|
|
XCCInputs ccInputs;
|
|
XOBDInputs obdInputs;
|
|
XAMAInputs amaInputs;
|
|
XRSIInputs rsiInputs;
|
|
XCHLHInputs chlhInputs;
|
|
XCHMAInputs chmaInputs;
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
//
|
|
// Validate ...
|
|
virtual bool IsValid()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = tsInputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
result = ctInputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = ccInputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = tmInputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = lhInputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = tdInputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = fiInputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = obdInputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = amaInputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = rsiInputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = chlhInputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = chmaInputs.IsValid();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Cleanup ...
|
|
virtual void Clean()
|
|
{
|
|
//
|
|
tsInputs.Clean();
|
|
ctInputs.Clean();
|
|
ccInputs.Clean();
|
|
tmInputs.Clean();
|
|
lhInputs.Clean();
|
|
tdInputs.Clean();
|
|
fiInputs.Clean();
|
|
obdInputs.Clean();
|
|
amaInputs.Clean();
|
|
rsiInputs.Clean();
|
|
chlhInputs.Clean();
|
|
chmaInputs.Clean();
|
|
}
|
|
|
|
//
|
|
// Default ...
|
|
virtual void Default()
|
|
{
|
|
//
|
|
tsInputs.Default();
|
|
ctInputs.Default();
|
|
ccInputs.Default();
|
|
tmInputs.Default();
|
|
lhInputs.Default();
|
|
tdInputs.Default();
|
|
fiInputs.Default();
|
|
obdInputs.Default();
|
|
amaInputs.Default();
|
|
rsiInputs.Default();
|
|
chlhInputs.Default();
|
|
chmaInputs.Default();
|
|
}
|
|
|
|
//
|
|
// Max ...
|
|
virtual int Max()
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
result = MathMax(lhInputs.Max(), tmInputs.Max());
|
|
|
|
//
|
|
result = MathMax(result, tsInputs.Max());
|
|
result = MathMax(result, ctInputs.Max());
|
|
result = MathMax(result, ccInputs.Max());
|
|
result = MathMax(result, tdInputs.Max());
|
|
result = MathMax(result, fiInputs.Max());
|
|
result = MathMax(result, obdInputs.Max());
|
|
result = MathMax(result, amaInputs.Max());
|
|
result = MathMax(result, rsiInputs.Max());
|
|
result = MathMax(result, chlhInputs.Max());
|
|
result = MathMax(result, chmaInputs.Max());
|
|
|
|
//
|
|
return result;
|
|
}
|
|
};
|
|
|
|
//
|
|
// XSC5MarketConditionDataCollector ...
|
|
class XSC5MarketConditionDataCollector
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
// Constructor ...
|
|
void XSC5MarketConditionDataCollector()
|
|
{
|
|
//
|
|
XSCDataCollector<X5MarketConditions> mBase;
|
|
mBase.Clear();
|
|
}
|
|
|
|
//
|
|
// Cleaning Store ...
|
|
void Clear()
|
|
{
|
|
//
|
|
XSCDataCollector<X5MarketConditions> mBase;
|
|
|
|
//
|
|
mBase.Clear();
|
|
}
|
|
|
|
//
|
|
// Add String Content ...
|
|
bool Add(string content)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
XSCDataCollector<X5MarketConditions> mBase;
|
|
|
|
//
|
|
result = mBase.Add(content);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Protected ...
|
|
protected:
|
|
//
|
|
// Private ...
|
|
private:
|
|
};
|
|
|
|
//
|
|
// X5 Provider Market Conditions ...
|
|
class X5MarketConditions : public XSCBaseProviderMarketConditions
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
// Buffers ...
|
|
|
|
//
|
|
// XTS ...
|
|
double tsCurrents[];
|
|
double tsNearests[];
|
|
double tsMediests[];
|
|
double tsFarests[];
|
|
|
|
//
|
|
// XFI ...
|
|
double fis[];
|
|
|
|
//
|
|
// XTD ...
|
|
double tdBullishs[];
|
|
double tdBearishs[];
|
|
double tdSignals[];
|
|
|
|
//
|
|
// XLH ...
|
|
double lhHhs[];
|
|
double lhLls[];
|
|
double lhSignals[];
|
|
|
|
//
|
|
// XTM ...
|
|
double tms[];
|
|
|
|
//
|
|
// XAMA ...
|
|
double amas[];
|
|
|
|
//
|
|
// XOBD ...
|
|
double obds[];
|
|
|
|
//
|
|
// XRSI ...
|
|
double rsis[];
|
|
|
|
//
|
|
// XCHMA ...
|
|
double chmaScFasts[];
|
|
double chmaScSlows[];
|
|
double chmaMcFasts[];
|
|
double chmaMcSlows[];
|
|
double chmaLcFasts[];
|
|
double chmaLcSlows[];
|
|
double chmaHotStates[];
|
|
|
|
//
|
|
// XCHLH ...
|
|
double chlhScHHs[];
|
|
double chlhScLLs[];
|
|
double chlhMcHHs[];
|
|
double chlhMcLLs[];
|
|
double chlhLcHHs[];
|
|
double chlhLcLLs[];
|
|
double chlhHotStates[];
|
|
|
|
//
|
|
// Conditional Variables ...
|
|
|
|
//
|
|
// XTM ...
|
|
bool isXTMPeak;
|
|
bool isXTMVale;
|
|
bool isXTMBullish;
|
|
bool isXTMBearish;
|
|
bool isXTMNeutural;
|
|
bool isXTMEndBullish;
|
|
bool isXTMEndBearish;
|
|
bool isXTMStartBullish;
|
|
bool isXTMStartBearish;
|
|
bool isXTMEndBullishByNeutural;
|
|
bool isXTMEndBearishByNeutural;
|
|
bool isXTMStartBullishAfterNeutural;
|
|
bool isXTMStartBearishAfterNeutural;
|
|
|
|
//
|
|
// XAMA ...
|
|
bool isXAMAPeak;
|
|
bool isXAMAVale;
|
|
bool isXAMABullish;
|
|
bool isXAMABearish;
|
|
bool isXAMANeutural;
|
|
bool isXAMAEndBullish;
|
|
bool isXAMAEndBearish;
|
|
bool isXAMAStartBullish;
|
|
bool isXAMAStartBearish;
|
|
bool isXAMAEndBullishByNeutural;
|
|
bool isXAMAEndBearishByNeutural;
|
|
bool isXAMAStartBullishAfterNeutural;
|
|
bool isXAMAStartBearishAfterNeutural;
|
|
|
|
//
|
|
// XLH ...
|
|
bool isXLHHHIncreased;
|
|
bool isXLHHHDecreased;
|
|
bool isXLHLLIncreased;
|
|
bool isXLHLLDecreased;
|
|
bool isXLHLowAttachedLL;
|
|
bool isXLHHighAttachedHH;
|
|
bool isXLHHHSameInLength;
|
|
bool isXLHLLSameInLength;
|
|
bool isXLHPriceOverSignal;
|
|
bool isXLHPriceUnderSignal;
|
|
bool isXLHPriceInSignalRange;
|
|
bool isXLHPriceCrossedOverSignal;
|
|
bool isXLHPriceCrossedUnderSignal;
|
|
|
|
//
|
|
// XTD ...
|
|
bool isXTDSignalPeak;
|
|
bool isXTDSignalVale;
|
|
bool isXTDBullishPeak;
|
|
bool isXTDBullishVale;
|
|
bool isXTDBearishPeak;
|
|
bool isXTDBearishVale;
|
|
bool isXTDBullOverBear;
|
|
bool isXTDBullUnderBear;
|
|
bool isXTDSignalOverBear;
|
|
bool isXTDSignalUnderBear;
|
|
bool isXTDBullCrossedOverBear;
|
|
bool isXTDBullCrossedUnderBear;
|
|
bool isXTDSignalCrossedOverBear;
|
|
bool isXTDSignalCrossedUnderBear;
|
|
|
|
//
|
|
// XFI ...
|
|
bool isXFIPeak;
|
|
bool isXFIVale;
|
|
bool isXFICrossedOverZero;
|
|
bool isXFIOverZero;
|
|
bool isXFICrossedUnderZero;
|
|
bool isXFIUnderZero;
|
|
|
|
//
|
|
// XTS ...
|
|
bool isXTSAllSame;
|
|
bool isXTSCurrentMin;
|
|
bool isXTSCurrentMax;
|
|
bool isXTSCurrentOverFarest;
|
|
bool isXTSCurrentOverNearest;
|
|
bool isXTSCurrentOverMediest;
|
|
bool isXTSCurrentUnderFarest;
|
|
bool isXTSCurrentUnderNearest;
|
|
bool isXTSCurrentUnderMediest;
|
|
bool isXTSCurrentCrossedOverFarest;
|
|
bool isXTSCurrentCrossedOverNearest;
|
|
bool isXTSCurrentCrossedOverMediest;
|
|
bool isXTSCurrentCrossedUnderFarest;
|
|
bool isXTSCurrentCrossedUnderNearest;
|
|
bool isXTSCurrentCrossedUnderMediest;
|
|
|
|
//
|
|
// XRSI ...
|
|
bool isXRSIPeak;
|
|
bool isXRSIVale;
|
|
bool isXRSICrossedOverLongExit;
|
|
bool isXRSICrossedOverLongEntry;
|
|
bool isXRSICrossedUnderShortExit;
|
|
bool isXRSICrossedUnderShortEntry;
|
|
|
|
//
|
|
// XOBD ...
|
|
bool isXOBDSwingLow;
|
|
bool isXOBDSwingHigh;
|
|
|
|
//
|
|
// XCHLH ...
|
|
//
|
|
bool isXCHLHSameHHs;
|
|
bool isXCHLHSameLLs;
|
|
//
|
|
bool isXCHLHSCMCHHSame;
|
|
bool isXCHLHSCMCLLSame;
|
|
//
|
|
bool isXCHLHSCLCHHSame;
|
|
bool isXCHLHSCLCLLSame;
|
|
//
|
|
bool isXCHLHMCLCHHSame;
|
|
bool isXCHLHMCLCLLSame;
|
|
//
|
|
bool isXCHLHMCOnTopOfLC;
|
|
bool isXCHLHMCInBottomOfLC;
|
|
|
|
//
|
|
// XCHMA ...
|
|
//
|
|
bool isXCHMASCOverMax;
|
|
bool isXCHMASCOverMin;
|
|
bool isXCHMASCUnderMax;
|
|
bool isXCHMASCUnderMin;
|
|
//
|
|
bool isXCHMASCCrossedOverMax;
|
|
bool isXCHMASCCrossedUnderMax;
|
|
bool isXCHMASCCrossedOverMin;
|
|
bool isXCHMASCCrossedUnderMin;
|
|
//
|
|
bool isXCHMASCPeak;
|
|
bool isXCHMASCVale;
|
|
bool isXCHMASCTrendsUp;
|
|
bool isXCHMASCTrendsDown;
|
|
bool isXCHMASCFastOverSlow;
|
|
bool isXCHMASCFastUnderSlow;
|
|
bool isXCHMASCFastCrossedOverSlow;
|
|
bool isXCHMASCFastCrossedUnderSlow;
|
|
//
|
|
bool isXCHMAMCPeak;
|
|
bool isXCHMAMCVale;
|
|
bool isXCHMAMCTrendsUp;
|
|
bool isXCHMAMCTrendsDown;
|
|
bool isXCHMAMCFastOverSlow;
|
|
bool isXCHMAMCFastUnderSlow;
|
|
bool isXCHMAMCFastCrossedOverSlow;
|
|
bool isXCHMAMCFastCrossedUnderSlow;
|
|
//
|
|
bool isXCHMALCPeak;
|
|
bool isXCHMALCVale;
|
|
bool isXCHMALCTrendsUp;
|
|
bool isXCHMALCTrendsDown;
|
|
bool isXCHMALCFastOverSlow;
|
|
bool isXCHMALCFastUnderSlow;
|
|
bool isXCHMALCFastCrossedOverSlow;
|
|
bool isXCHMALCFastCrossedUnderSlow;
|
|
|
|
//
|
|
|
|
//
|
|
// Conditions ...
|
|
void Clear()
|
|
{
|
|
//
|
|
Clean(tsCurrents);
|
|
Clean(tsNearests);
|
|
Clean(tsMediests);
|
|
Clean(tsFarests);
|
|
Clean(fis);
|
|
Clean(tdBullishs);
|
|
Clean(tdBearishs);
|
|
Clean(tdSignals);
|
|
Clean(lhHhs);
|
|
Clean(lhLls);
|
|
Clean(lhSignals);
|
|
Clean(tms);
|
|
Clean(amas);
|
|
Clean(obds);
|
|
Clean(rsis);
|
|
Clean(chmaScFasts);
|
|
Clean(chmaScSlows);
|
|
Clean(chmaMcFasts);
|
|
Clean(chmaMcSlows);
|
|
Clean(chmaLcFasts);
|
|
Clean(chmaLcSlows);
|
|
Clean(chmaHotStates);
|
|
Clean(chlhScHHs);
|
|
Clean(chlhScLLs);
|
|
Clean(chlhMcHHs);
|
|
Clean(chlhMcLLs);
|
|
Clean(chlhLcHHs);
|
|
Clean(chlhLcLLs);
|
|
Clean(chlhHotStates);
|
|
|
|
//
|
|
ArraySetAsSeries(tsCurrents, true);
|
|
ArraySetAsSeries(tsNearests, true);
|
|
ArraySetAsSeries(tsMediests, true);
|
|
ArraySetAsSeries(tsFarests, true);
|
|
ArraySetAsSeries(fis, true);
|
|
ArraySetAsSeries(tdBullishs, true);
|
|
ArraySetAsSeries(tdBearishs, true);
|
|
ArraySetAsSeries(tdSignals, true);
|
|
ArraySetAsSeries(lhHhs, true);
|
|
ArraySetAsSeries(lhLls, true);
|
|
ArraySetAsSeries(lhSignals, true);
|
|
ArraySetAsSeries(tms, true);
|
|
ArraySetAsSeries(amas, true);
|
|
ArraySetAsSeries(obds, true);
|
|
ArraySetAsSeries(rsis, true);
|
|
ArraySetAsSeries(chmaScFasts, true);
|
|
ArraySetAsSeries(chmaScSlows, true);
|
|
ArraySetAsSeries(chmaMcFasts, true);
|
|
ArraySetAsSeries(chmaMcSlows, true);
|
|
ArraySetAsSeries(chmaLcFasts, true);
|
|
ArraySetAsSeries(chmaLcSlows, true);
|
|
ArraySetAsSeries(chmaHotStates, true);
|
|
ArraySetAsSeries(chlhScHHs, true);
|
|
ArraySetAsSeries(chlhScLLs, true);
|
|
ArraySetAsSeries(chlhMcHHs, true);
|
|
ArraySetAsSeries(chlhMcLLs, true);
|
|
ArraySetAsSeries(chlhLcHHs, true);
|
|
ArraySetAsSeries(chlhLcLLs, true);
|
|
ArraySetAsSeries(chlhHotStates, true);
|
|
|
|
//
|
|
isXTMPeak = false;
|
|
isXTMVale = false;
|
|
isXTMBullish = false;
|
|
isXTMBearish = false;
|
|
isXTMNeutural = false;
|
|
isXTMEndBullish = false;
|
|
isXTMEndBearish = false;
|
|
isXTMStartBullish = false;
|
|
isXTMStartBearish = false;
|
|
isXTMEndBullishByNeutural = false;
|
|
isXTMEndBearishByNeutural = false;
|
|
isXTMStartBullishAfterNeutural = false;
|
|
isXTMStartBearishAfterNeutural = false;
|
|
isXAMAPeak = false;
|
|
isXAMAVale = false;
|
|
isXAMABullish = false;
|
|
isXAMABearish = false;
|
|
isXAMANeutural = false;
|
|
isXAMAEndBullish = false;
|
|
isXAMAEndBearish = false;
|
|
isXAMAStartBullish = false;
|
|
isXAMAStartBearish = false;
|
|
isXAMAEndBullishByNeutural = false;
|
|
isXAMAEndBearishByNeutural = false;
|
|
isXAMAStartBullishAfterNeutural = false;
|
|
isXAMAStartBearishAfterNeutural = false;
|
|
isXLHHHIncreased = false;
|
|
isXLHHHDecreased = false;
|
|
isXLHLLIncreased = false;
|
|
isXLHLLDecreased = false;
|
|
isXLHLowAttachedLL = false;
|
|
isXLHHighAttachedHH = false;
|
|
isXLHHHSameInLength = false;
|
|
isXLHLLSameInLength = false;
|
|
isXLHPriceOverSignal = false;
|
|
isXLHPriceUnderSignal = false;
|
|
isXLHPriceInSignalRange = false;
|
|
isXLHPriceCrossedOverSignal = false;
|
|
isXLHPriceCrossedUnderSignal = false;
|
|
isXTDSignalPeak = false;
|
|
isXTDSignalVale = false;
|
|
isXTDBullishPeak = false;
|
|
isXTDBullishVale = false;
|
|
isXTDBearishPeak = false;
|
|
isXTDBearishVale = false;
|
|
isXTDBullOverBear = false;
|
|
isXTDBullUnderBear = false;
|
|
isXTDSignalOverBear = false;
|
|
isXTDSignalUnderBear = false;
|
|
isXTDBullCrossedOverBear = false;
|
|
isXTDBullCrossedUnderBear = false;
|
|
isXTDSignalCrossedOverBear = false;
|
|
isXTDSignalCrossedUnderBear = false;
|
|
isXFIPeak = false;
|
|
isXFIVale = false;
|
|
isXFICrossedOverZero = false;
|
|
isXFIOverZero = false;
|
|
isXFICrossedUnderZero = false;
|
|
isXFIUnderZero = false;
|
|
isXTSAllSame = false;
|
|
isXTSCurrentMin = false;
|
|
isXTSCurrentMax = false;
|
|
isXTSCurrentOverFarest = false;
|
|
isXTSCurrentOverNearest = false;
|
|
isXTSCurrentOverMediest = false;
|
|
isXTSCurrentUnderFarest = false;
|
|
isXTSCurrentUnderNearest = false;
|
|
isXTSCurrentUnderMediest = false;
|
|
isXTSCurrentCrossedOverFarest = false;
|
|
isXTSCurrentCrossedOverNearest = false;
|
|
isXTSCurrentCrossedOverMediest = false;
|
|
isXTSCurrentCrossedUnderFarest = false;
|
|
isXTSCurrentCrossedUnderNearest = false;
|
|
isXTSCurrentCrossedUnderMediest = false;
|
|
isXRSIPeak = false;
|
|
isXRSIVale = false;
|
|
isXRSICrossedOverLongExit = false;
|
|
isXRSICrossedOverLongEntry = false;
|
|
isXRSICrossedUnderShortExit = false;
|
|
isXRSICrossedUnderShortEntry = false;
|
|
isXOBDSwingLow = false;
|
|
isXOBDSwingHigh = false;
|
|
isXCHLHSameHHs = false;
|
|
isXCHLHSameLLs = false;
|
|
isXCHLHSCMCHHSame = false;
|
|
isXCHLHSCMCLLSame = false;
|
|
isXCHLHSCLCHHSame = false;
|
|
isXCHLHSCLCLLSame = false;
|
|
isXCHLHMCLCHHSame = false;
|
|
isXCHLHMCLCLLSame = false;
|
|
isXCHLHMCOnTopOfLC = false;
|
|
isXCHLHMCInBottomOfLC = false;
|
|
isXCHMASCOverMax = false;
|
|
isXCHMASCOverMin = false;
|
|
isXCHMASCUnderMax = false;
|
|
isXCHMASCUnderMin = false;
|
|
isXCHMASCCrossedOverMax = false;
|
|
isXCHMASCCrossedUnderMax = false;
|
|
isXCHMASCCrossedOverMin = false;
|
|
isXCHMASCCrossedUnderMin = false;
|
|
isXCHMASCPeak = false;
|
|
isXCHMASCVale = false;
|
|
isXCHMASCTrendsUp = false;
|
|
isXCHMASCTrendsDown = false;
|
|
isXCHMASCFastOverSlow = false;
|
|
isXCHMASCFastUnderSlow = false;
|
|
isXCHMASCFastCrossedOverSlow = false;
|
|
isXCHMASCFastCrossedUnderSlow = false;
|
|
isXCHMAMCPeak = false;
|
|
isXCHMAMCVale = false;
|
|
isXCHMAMCTrendsUp = false;
|
|
isXCHMAMCTrendsDown = false;
|
|
isXCHMAMCFastOverSlow = false;
|
|
isXCHMAMCFastUnderSlow = false;
|
|
isXCHMAMCFastCrossedOverSlow = false;
|
|
isXCHMAMCFastCrossedUnderSlow = false;
|
|
isXCHMALCPeak = false;
|
|
isXCHMALCVale = false;
|
|
isXCHMALCTrendsUp = false;
|
|
isXCHMALCTrendsDown = false;
|
|
isXCHMALCFastOverSlow = false;
|
|
isXCHMALCFastUnderSlow = false;
|
|
isXCHMALCFastCrossedOverSlow = false;
|
|
isXCHMALCFastCrossedUnderSlow = false;
|
|
}
|
|
|
|
//
|
|
// Generate Score ...
|
|
virtual void GenerateScore(
|
|
double &bullishScore, // Bullish Score
|
|
double &bearishScore, // Bearish Score
|
|
const double multiplier = 1 // Score Multiplier
|
|
)
|
|
{
|
|
}
|
|
|
|
//
|
|
// Generate Summary ...
|
|
virtual string GenerateSummary(
|
|
const double multiplier = 1, // Score Multiplier
|
|
const string separator = "\n", // Separator
|
|
const bool ignoreFalseConditions = true // Ignore False Conditions
|
|
)
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
// Common ...
|
|
string commonStr =
|
|
//
|
|
"Commons: " + separator +
|
|
"-----------------------------" +
|
|
"Time: " + ToString(TimeCurrent()) + separator +
|
|
//
|
|
// TODO: Add Scores Later ...
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
// XOBD ...
|
|
string obdStr =
|
|
//
|
|
ToString("isXOBDSwingLow", isXOBDSwingLow, ignoreFalseConditions) +
|
|
ToString("isXOBDSwingHigh", isXOBDSwingHigh, ignoreFalseConditions) +
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
// ToString("", , ignoreFalseConditions) +
|
|
|
|
//
|
|
// XFI ...
|
|
string fiStr =
|
|
//
|
|
ToString("isXFIPeak", isXFIPeak, ignoreFalseConditions) +
|
|
ToString("isXFIVale", isXFIVale, ignoreFalseConditions) +
|
|
ToString("isXFICrossedOverZero", isXFICrossedOverZero, ignoreFalseConditions) +
|
|
ToString("isXFIOverZero", isXFIOverZero, ignoreFalseConditions) +
|
|
ToString("isXFICrossedUnderZero", isXFICrossedUnderZero, ignoreFalseConditions) +
|
|
ToString("isXFIUnderZero", isXFIUnderZero, ignoreFalseConditions) +
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
// XRSI ...
|
|
string rsiStr =
|
|
//
|
|
ToString("isXRSIPeak", isXRSIPeak, ignoreFalseConditions) +
|
|
ToString("isXRSIVale", isXRSIVale, ignoreFalseConditions) +
|
|
ToString("isXRSICrossedOverLongExit", isXRSICrossedOverLongExit, ignoreFalseConditions) +
|
|
ToString("isXRSICrossedOverLongEntry", isXRSICrossedOverLongEntry, ignoreFalseConditions) +
|
|
ToString("isXRSICrossedUnderShortExit", isXRSICrossedUnderShortExit, ignoreFalseConditions) +
|
|
ToString("isXRSICrossedUnderShortEntry", isXRSICrossedUnderShortEntry, ignoreFalseConditions) +
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
// XTM ...
|
|
string tmStr =
|
|
//
|
|
ToString("isXTMPeak", isXTMPeak, ignoreFalseConditions) +
|
|
ToString("isXTMVale", isXTMVale, ignoreFalseConditions) +
|
|
ToString("isXTMBullish", isXTMBullish, ignoreFalseConditions) +
|
|
ToString("isXTMBearish", isXTMBearish, ignoreFalseConditions) +
|
|
ToString("isXTMNeutural", isXTMNeutural, ignoreFalseConditions) +
|
|
ToString("isXTMEndBullish", isXTMEndBullish, ignoreFalseConditions) +
|
|
ToString("isXTMEndBearish", isXTMEndBearish, ignoreFalseConditions) +
|
|
ToString("isXTMStartBullish", isXTMStartBullish, ignoreFalseConditions) +
|
|
ToString("isXTMStartBearish", isXTMStartBearish, ignoreFalseConditions) +
|
|
ToString("isXTMEndBullishByNeutural", isXTMEndBullishByNeutural, ignoreFalseConditions) +
|
|
ToString("isXTMEndBearishByNeutural", isXTMEndBearishByNeutural, ignoreFalseConditions) +
|
|
ToString("isXTMStartBullishAfterNeutural", isXTMStartBullishAfterNeutural, ignoreFalseConditions) +
|
|
ToString("isXTMStartBearishAfterNeutural", isXTMStartBearishAfterNeutural, ignoreFalseConditions) +
|
|
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
// XAMA ...
|
|
string amaStr =
|
|
//
|
|
ToString("isXAMAPeak", isXAMAPeak, ignoreFalseConditions) +
|
|
ToString("isXAMAVale", isXAMAVale, ignoreFalseConditions) +
|
|
ToString("isXAMABullish", isXAMABullish, ignoreFalseConditions) +
|
|
ToString("isXAMABearish", isXAMABearish, ignoreFalseConditions) +
|
|
ToString("isXAMANeutural", isXAMANeutural, ignoreFalseConditions) +
|
|
ToString("isXAMAEndBullish", isXAMAEndBullish, ignoreFalseConditions) +
|
|
ToString("isXAMAEndBearish", isXAMAEndBearish, ignoreFalseConditions) +
|
|
ToString("isXAMAStartBullish", isXAMAStartBullish, ignoreFalseConditions) +
|
|
ToString("isXAMAStartBearish", isXAMAStartBearish, ignoreFalseConditions) +
|
|
ToString("isXAMAEndBullishByNeutural", isXAMAEndBullishByNeutural, ignoreFalseConditions) +
|
|
ToString("isXAMAEndBearishByNeutural", isXAMAEndBearishByNeutural, ignoreFalseConditions) +
|
|
ToString("isXAMAStartBullishAfterNeutural", isXAMAStartBullishAfterNeutural, ignoreFalseConditions) +
|
|
ToString("isXAMAStartBearishAfterNeutural", isXAMAStartBearishAfterNeutural, ignoreFalseConditions) +
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
// XLH ...
|
|
string lhStr =
|
|
//
|
|
ToString("isXLHHHIncreased", isXLHHHIncreased, ignoreFalseConditions) +
|
|
ToString("isXLHHHDecreased", isXLHHHDecreased, ignoreFalseConditions) +
|
|
ToString("isXLHLLIncreased", isXLHLLIncreased, ignoreFalseConditions) +
|
|
ToString("isXLHLLDecreased", isXLHLLDecreased, ignoreFalseConditions) +
|
|
ToString("isXLHLowAttachedLL", isXLHLowAttachedLL, ignoreFalseConditions) +
|
|
ToString("isXLHHighAttachedHH", isXLHHighAttachedHH, ignoreFalseConditions) +
|
|
ToString("isXLHHHSameInLength", isXLHHHSameInLength, ignoreFalseConditions) +
|
|
ToString("isXLHLLSameInLength", isXLHLLSameInLength, ignoreFalseConditions) +
|
|
ToString("isXLHPriceOverSignal", isXLHPriceOverSignal, ignoreFalseConditions) +
|
|
ToString("isXLHPriceUnderSignal", isXLHPriceUnderSignal, ignoreFalseConditions) +
|
|
ToString("isXLHPriceInSignalRange", isXLHPriceInSignalRange, ignoreFalseConditions) +
|
|
ToString("isXLHPriceCrossedOverSignal", isXLHPriceCrossedOverSignal, ignoreFalseConditions) +
|
|
ToString("isXLHPriceCrossedUnderSignal", isXLHPriceCrossedUnderSignal, ignoreFalseConditions) +
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
// XTD ...
|
|
string tdStr =
|
|
//
|
|
ToString("isXTDSignalPeak", isXTDSignalPeak, ignoreFalseConditions) +
|
|
ToString("isXTDSignalVale", isXTDSignalVale, ignoreFalseConditions) +
|
|
ToString("isXTDBullishPeak", isXTDBullishPeak, ignoreFalseConditions) +
|
|
ToString("isXTDBullishVale", isXTDBullishVale, ignoreFalseConditions) +
|
|
ToString("isXTDBearishPeak", isXTDBearishPeak, ignoreFalseConditions) +
|
|
ToString("isXTDBearishVale", isXTDBearishVale, ignoreFalseConditions) +
|
|
ToString("isXTDBullOverBear", isXTDBullOverBear, ignoreFalseConditions) +
|
|
ToString("isXTDBullUnderBear", isXTDBullUnderBear, ignoreFalseConditions) +
|
|
ToString("isXTDSignalOverBear", isXTDSignalOverBear, ignoreFalseConditions) +
|
|
ToString("isXTDSignalUnderBear", isXTDSignalUnderBear, ignoreFalseConditions) +
|
|
ToString("isXTDBullCrossedOverBear", isXTDBullCrossedOverBear, ignoreFalseConditions) +
|
|
ToString("isXTDBullCrossedUnderBear", isXTDBullCrossedUnderBear, ignoreFalseConditions) +
|
|
ToString("isXTDSignalCrossedOverBear", isXTDSignalCrossedOverBear, ignoreFalseConditions) +
|
|
ToString("isXTDSignalCrossedUnderBear", isXTDSignalCrossedUnderBear, ignoreFalseConditions) +
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
// XTS ...
|
|
string tsStr =
|
|
//
|
|
ToString("isXTSAllSame", isXTSAllSame, ignoreFalseConditions) +
|
|
ToString("isXTSCurrentMin", isXTSCurrentMin, ignoreFalseConditions) +
|
|
ToString("isXTSCurrentMax", isXTSCurrentMax, ignoreFalseConditions) +
|
|
ToString("isXTSCurrentOverFarest", isXTSCurrentOverFarest, ignoreFalseConditions) +
|
|
ToString("isXTSCurrentOverNearest", isXTSCurrentOverNearest, ignoreFalseConditions) +
|
|
ToString("isXTSCurrentOverMediest", isXTSCurrentOverMediest, ignoreFalseConditions) +
|
|
ToString("isXTSCurrentUnderFarest", isXTSCurrentUnderFarest, ignoreFalseConditions) +
|
|
ToString("isXTSCurrentUnderNearest", isXTSCurrentUnderNearest, ignoreFalseConditions) +
|
|
ToString("isXTSCurrentUnderMediest", isXTSCurrentUnderMediest, ignoreFalseConditions) +
|
|
ToString("isXTSCurrentCrossedOverFarest", isXTSCurrentCrossedOverFarest, ignoreFalseConditions) +
|
|
ToString("isXTSCurrentCrossedOverNearest", isXTSCurrentCrossedOverNearest, ignoreFalseConditions) +
|
|
ToString("isXTSCurrentCrossedOverMediest", isXTSCurrentCrossedOverMediest, ignoreFalseConditions) +
|
|
ToString("isXTSCurrentCrossedUnderFarest", isXTSCurrentCrossedUnderFarest, ignoreFalseConditions) +
|
|
ToString("isXTSCurrentCrossedUnderNearest", isXTSCurrentCrossedUnderNearest, ignoreFalseConditions) +
|
|
ToString("isXTSCurrentCrossedUnderMediest", isXTSCurrentCrossedUnderMediest, ignoreFalseConditions) +
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
// XCHLH ...
|
|
string chlhStr =
|
|
//
|
|
ToString("isXCHLHSameHHs", isXCHLHSameHHs, ignoreFalseConditions) +
|
|
ToString("isXCHLHSameLLs", isXCHLHSameLLs, ignoreFalseConditions) +
|
|
ToString("isXCHLHSCMCHHSame", isXCHLHSCMCHHSame, ignoreFalseConditions) +
|
|
ToString("isXCHLHSCMCLLSame", isXCHLHSCMCLLSame, ignoreFalseConditions) +
|
|
ToString("isXCHLHSCLCHHSame", isXCHLHSCLCHHSame, ignoreFalseConditions) +
|
|
ToString("isXCHLHSCLCLLSame", isXCHLHSCLCLLSame, ignoreFalseConditions) +
|
|
ToString("isXCHLHMCLCHHSame", isXCHLHMCLCHHSame, ignoreFalseConditions) +
|
|
ToString("isXCHLHMCLCLLSame", isXCHLHMCLCLLSame, ignoreFalseConditions) +
|
|
ToString("isXCHLHMCOnTopOfLC", isXCHLHMCOnTopOfLC, ignoreFalseConditions) +
|
|
ToString("isXCHLHMCInBottomOfLC", isXCHLHMCInBottomOfLC, ignoreFalseConditions) +
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
// XCHMA ...
|
|
string chmaStr =
|
|
//
|
|
ToString("isXCHMASCOverMax", isXCHMASCOverMax, ignoreFalseConditions) +
|
|
ToString("isXCHMASCOverMin", isXCHMASCOverMin, ignoreFalseConditions) +
|
|
ToString("isXCHMASCUnderMax", isXCHMASCUnderMax, ignoreFalseConditions) +
|
|
ToString("isXCHMASCUnderMin", isXCHMASCUnderMin, ignoreFalseConditions) +
|
|
ToString("isXCHMASCCrossedOverMax", isXCHMASCCrossedOverMax, ignoreFalseConditions) +
|
|
ToString("isXCHMASCCrossedUnderMax", isXCHMASCCrossedUnderMax, ignoreFalseConditions) +
|
|
ToString("isXCHMASCCrossedOverMin", isXCHMASCCrossedOverMin, ignoreFalseConditions) +
|
|
ToString("isXCHMASCCrossedUnderMin", isXCHMASCCrossedUnderMin, ignoreFalseConditions) +
|
|
ToString("isXCHMASCPeak", isXCHMASCPeak, ignoreFalseConditions) +
|
|
ToString("isXCHMASCVale", isXCHMASCVale, ignoreFalseConditions) +
|
|
ToString("isXCHMASCTrendsUp", isXCHMASCTrendsUp, ignoreFalseConditions) +
|
|
ToString("isXCHMASCTrendsDown", isXCHMASCTrendsDown, ignoreFalseConditions) +
|
|
ToString("isXCHMASCFastOverSlow", isXCHMASCFastOverSlow, ignoreFalseConditions) +
|
|
ToString("isXCHMASCFastUnderSlow", isXCHMASCFastUnderSlow, ignoreFalseConditions) +
|
|
ToString("isXCHMASCFastCrossedOverSlow", isXCHMASCFastCrossedOverSlow, ignoreFalseConditions) +
|
|
ToString("isXCHMASCFastCrossedUnderSlow", isXCHMASCFastCrossedUnderSlow, ignoreFalseConditions) +
|
|
ToString("isXCHMAMCPeak", isXCHMAMCPeak, ignoreFalseConditions) +
|
|
ToString("isXCHMAMCVale", isXCHMAMCVale, ignoreFalseConditions) +
|
|
ToString("isXCHMAMCTrendsUp", isXCHMAMCTrendsUp, ignoreFalseConditions) +
|
|
ToString("isXCHMAMCTrendsDown", isXCHMAMCTrendsDown, ignoreFalseConditions) +
|
|
ToString("isXCHMAMCFastOverSlow", isXCHMAMCFastOverSlow, ignoreFalseConditions) +
|
|
ToString("isXCHMAMCFastUnderSlow", isXCHMAMCFastUnderSlow, ignoreFalseConditions) +
|
|
ToString("isXCHMAMCFastCrossedOverSlow", isXCHMAMCFastCrossedOverSlow, ignoreFalseConditions) +
|
|
ToString("isXCHMAMCFastCrossedUnderSlow", isXCHMAMCFastCrossedUnderSlow, ignoreFalseConditions) +
|
|
ToString("isXCHMALCPeak", isXCHMALCPeak, ignoreFalseConditions) +
|
|
ToString("isXCHMALCVale", isXCHMALCVale, ignoreFalseConditions) +
|
|
ToString("isXCHMALCTrendsUp", isXCHMALCTrendsUp, ignoreFalseConditions) +
|
|
ToString("isXCHMALCTrendsDown", isXCHMALCTrendsDown, ignoreFalseConditions) +
|
|
ToString("isXCHMALCFastOverSlow", isXCHMALCFastOverSlow, ignoreFalseConditions) +
|
|
ToString("isXCHMALCFastUnderSlow", isXCHMALCFastUnderSlow, ignoreFalseConditions) +
|
|
ToString("isXCHMALCFastCrossedOverSlow", isXCHMALCFastCrossedOverSlow, ignoreFalseConditions) +
|
|
ToString("isXCHMALCFastCrossedUnderSlow", isXCHMALCFastCrossedUnderSlow, ignoreFalseConditions) +
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
// Generating Full Result by Combining parts ...
|
|
result =
|
|
//
|
|
"[" + GetToken() + "]" + separator +
|
|
"----------------------" + separator +
|
|
commonStr +
|
|
obdStr +
|
|
fiStr +
|
|
rsiStr +
|
|
tmStr +
|
|
amaStr +
|
|
lhStr +
|
|
tdStr +
|
|
tsStr +
|
|
chlhStr +
|
|
chmaStr +
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// For Data Collector ...
|
|
bool IsModelValid()
|
|
{
|
|
return false;
|
|
}
|
|
string ToModelString()
|
|
{
|
|
return NULL;
|
|
}
|
|
bool ParseModel(string content)
|
|
{
|
|
return false;
|
|
}
|
|
int FindIndex(X5MarketConditions &items[])
|
|
{
|
|
return -1;
|
|
}
|
|
};
|
|
|
|
//
|
|
// Class ...
|
|
|
|
//
|
|
// X5 Provider Class ...
|
|
class XSCX5Provider : public XSCBaseProvider
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
// Props ...
|
|
XSCXTSHelper *tsHelper;
|
|
XSCXFIHelper *fiHelper;
|
|
XSCXTDHelper *tdHelper;
|
|
XSCXLHHelper *lhHelper;
|
|
XSCXTMHelper *tmHelper;
|
|
XSCXCCHelper *ccHelper;
|
|
XSCXCTHelper *ctHelper;
|
|
XSCXOBDHelper *obdHelper;
|
|
XSCXRSIHelper *rsiHelper;
|
|
XSCXAMAHelper *amaHelper;
|
|
XSCXCHMAHelper *chmaHelper;
|
|
XSCXCHLHHelper *chlhHelper;
|
|
|
|
//
|
|
// Constructor ...
|
|
XSCX5Provider(
|
|
string symbol, // Trading Symbol
|
|
ENUM_TIMEFRAMES period // Trading PEriod
|
|
) : XSCBaseProvider(symbol, period)
|
|
{
|
|
//
|
|
tsHelper = new XSCXTSHelper();
|
|
fiHelper = new XSCXFIHelper();
|
|
tdHelper = new XSCXTDHelper();
|
|
lhHelper = new XSCXLHHelper();
|
|
tmHelper = new XSCXTMHelper();
|
|
ccHelper = new XSCXCCHelper();
|
|
ctHelper = new XSCXCTHelper();
|
|
obdHelper = new XSCXOBDHelper();
|
|
rsiHelper = new XSCXRSIHelper();
|
|
amaHelper = new XSCXAMAHelper();
|
|
chmaHelper = new XSCXCHMAHelper();
|
|
chlhHelper = new XSCXCHLHHelper();
|
|
|
|
//
|
|
mNumberOfItems = 15;
|
|
}
|
|
|
|
//
|
|
// Properties Gettr(s) / Setter(s) ...
|
|
|
|
//
|
|
// Inheritance ...
|
|
|
|
//
|
|
// Init all Requirements ...
|
|
virtual bool Init(X5ProviderInputs &inputs)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Validate ...
|
|
result = inputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mInputs = inputs;
|
|
|
|
//
|
|
string mSymbol = GetSymbol();
|
|
ENUM_TIMEFRAMES mPeriod = GetPeriod();
|
|
|
|
//
|
|
result = tsHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.tsInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = fiHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.fiInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = tdHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.tdInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = lhHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.lhInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = tmHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.tmInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = ccHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.ccInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = ctHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.ctInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = obdHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.obdInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = rsiHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.rsiInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = amaHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.amaInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = chmaHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.chmaInputs
|
|
//
|
|
);
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
result = chlhHelper
|
|
.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
mInputs.chlhInputs
|
|
//
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// DeInit all Requirements ...
|
|
virtual void DeInit()
|
|
{
|
|
//
|
|
delete tsHelper;
|
|
delete fiHelper;
|
|
delete tdHelper;
|
|
delete lhHelper;
|
|
delete tmHelper;
|
|
delete ccHelper;
|
|
delete ctHelper;
|
|
delete obdHelper;
|
|
delete rsiHelper;
|
|
delete amaHelper;
|
|
delete chmaHelper;
|
|
delete chlhHelper;
|
|
}
|
|
|
|
//
|
|
// Functions ...
|
|
|
|
//
|
|
virtual string GetTag()
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
result =
|
|
//
|
|
GetToken() +
|
|
"[" +
|
|
GetSymbol() +
|
|
"," +
|
|
ToString(GetPeriod()) +
|
|
"]"
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
virtual void GetMarketConditions(
|
|
X5MarketConditions &mConditions, // Market Conditions Result
|
|
int barIndex = 0 // Specified Bar Index
|
|
)
|
|
{
|
|
//
|
|
mConditions.Clear();
|
|
|
|
//
|
|
// XTM ...
|
|
tmHelper.CopyMain(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.tms);
|
|
|
|
//
|
|
// XAMA ...
|
|
amaHelper.CopyMain(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.amas);
|
|
|
|
//
|
|
// XFI ...
|
|
fiHelper.CopyMain(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.fis);
|
|
|
|
//
|
|
// XOBD ...
|
|
obdHelper.CopyMain(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.obds);
|
|
|
|
//
|
|
// XRSI ...
|
|
rsiHelper.CopyMain(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.rsis);
|
|
|
|
//
|
|
// XLH ...
|
|
|
|
//
|
|
// HH ...
|
|
lhHelper.CopyHH(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.lhHhs);
|
|
|
|
//
|
|
// LL ...
|
|
lhHelper.CopyLL(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.lhLls);
|
|
|
|
//
|
|
// Signal ...
|
|
lhHelper.CopySignal(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.lhSignals);
|
|
|
|
//
|
|
// XTD ...
|
|
|
|
//
|
|
// Bullish ...
|
|
tdHelper.CopyBullish(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.tdBullishs);
|
|
|
|
//
|
|
// Bearish ...
|
|
tdHelper.CopyBearish(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.tdBearishs);
|
|
|
|
//
|
|
// Signal ...
|
|
tdHelper.CopySignal(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.tdSignals);
|
|
|
|
//
|
|
// XTS ...
|
|
|
|
//
|
|
// Current ...
|
|
tsHelper.CopyCurrent(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.tsCurrents);
|
|
|
|
//
|
|
// Nearest ...
|
|
tsHelper.CopyNearest(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.tsNearests);
|
|
|
|
//
|
|
// Mediest ...
|
|
tsHelper.CopyMediest(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.tsMediests);
|
|
|
|
//
|
|
// Farest ...
|
|
tsHelper.CopyFarest(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.tsFarests);
|
|
|
|
//
|
|
// XCHMA ...
|
|
|
|
//
|
|
// Short ...
|
|
|
|
//
|
|
// Fast ...
|
|
chmaHelper.CopySCFast(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.chmaScFasts);
|
|
|
|
//
|
|
// Slow ...
|
|
chmaHelper.CopySCSlow(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.chmaScSlows);
|
|
|
|
//
|
|
// Medium ...
|
|
|
|
//
|
|
// Fast ...
|
|
chmaHelper.CopyMCFast(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.chmaMcFasts);
|
|
|
|
//
|
|
// Slow ...
|
|
chmaHelper.CopyMCSlow(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.chmaMcSlows);
|
|
|
|
//
|
|
// Long ...
|
|
|
|
//
|
|
// Fast ...
|
|
chmaHelper.CopyLCFast(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.chmaLcFasts);
|
|
|
|
//
|
|
// Slow ...
|
|
chmaHelper.CopyLCSlow(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.chmaLcSlows);
|
|
|
|
//
|
|
// Hot States ...
|
|
chmaHelper.CopyHotState(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.chmaHotStates);
|
|
|
|
//
|
|
// XCHLH ...
|
|
|
|
//
|
|
// Short ...
|
|
|
|
//
|
|
// HH ...
|
|
chlhHelper.CopySCHH(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.chlhScHHs);
|
|
|
|
//
|
|
// LL ...
|
|
chlhHelper.CopySCLL(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.chlhScLLs);
|
|
|
|
//
|
|
// Medium ...
|
|
|
|
//
|
|
// HH ...
|
|
chlhHelper.CopyMCHH(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.chlhMcHHs);
|
|
|
|
//
|
|
// LL ...
|
|
chlhHelper.CopyMCLL(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.chlhMcLLs);
|
|
|
|
//
|
|
// Long ...
|
|
|
|
//
|
|
// HH ...
|
|
chlhHelper.CopyLCHH(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.chlhLcHHs);
|
|
|
|
//
|
|
// LL ...
|
|
chlhHelper.CopyLCLL(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.chlhLcLLs);
|
|
|
|
//
|
|
// Hot State ...
|
|
chlhHelper.CopyHotState(
|
|
barIndex,
|
|
mNumberOfItems,
|
|
mConditions.chlhHotStates);
|
|
|
|
//
|
|
// Filling Bars ...
|
|
mCycle.GetBars(
|
|
mConditions.bars,
|
|
0,
|
|
mNumberOfItems);
|
|
|
|
//
|
|
CalculateConditions(mConditions);
|
|
}
|
|
|
|
//
|
|
// Check Market For Signal ...
|
|
virtual bool HasSignal(
|
|
int barIndex,
|
|
XSignal &mSignal, // Hold's Signal if Exists ...
|
|
X5MarketConditions &mConditions // Hold's Market Conditions ...
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = !CanIgnoreProcess();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
GetMarketConditions(mConditions, barIndex);
|
|
|
|
//
|
|
if (result)
|
|
{
|
|
//
|
|
string mConditionsStr = mConditions.GenerateSummary();
|
|
mConditionsCollector.Add(mConditionsStr);
|
|
Print("Conditions: " + "\n" + mConditionsStr);
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Protected ...
|
|
protected:
|
|
//
|
|
X5ProviderInputs mInputs;
|
|
|
|
//
|
|
// Private ...
|
|
private:
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
// Prepare an Instance of Data Collector for MarketConditions ...
|
|
XSC5MarketConditionDataCollector mConditionsCollector;
|
|
|
|
//
|
|
int mNumberOfItems; // Number of Buffer Ites Read in Conditions ...
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
//
|
|
// Calculate Conditions ...
|
|
void CalculateConditions(X5MarketConditions &mConditions)
|
|
{
|
|
//
|
|
CalculateTMConditions(mConditions);
|
|
CalculateAMAConditions(mConditions);
|
|
CalculateFIConditions(mConditions);
|
|
CalculateOBDConditions(mConditions);
|
|
CalculateRSIConditions(mConditions);
|
|
CalculateCHLHConditions(mConditions);
|
|
CalculateLHConditions(mConditions);
|
|
CalculateTDConditions(mConditions);
|
|
CalculateTSConditions(mConditions);
|
|
CalculateCHMAConditions(mConditions);
|
|
}
|
|
|
|
//
|
|
// XTM ..
|
|
void CalculateTMConditions(X5MarketConditions &mConditions)
|
|
{
|
|
//
|
|
int mIndex = 0;
|
|
int mPrevIndex = mIndex + 1;
|
|
int mLength = 10;
|
|
int mFrom = mIndex + mLength;
|
|
|
|
//
|
|
mConditions.isXTMPeak = IsIncreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.tms);
|
|
|
|
//
|
|
mConditions.isXTMVale = IsDecreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.tms);
|
|
|
|
//
|
|
mConditions.isXTMBullish = mConditions.bars[mIndex].low > mConditions.tms[mIndex];
|
|
bool isXTMBullishPrev = mConditions.bars[mPrevIndex].low > mConditions.tms[mPrevIndex];
|
|
|
|
//
|
|
mConditions.isXTMBearish = mConditions.bars[mIndex].high < mConditions.tms[mIndex];
|
|
bool isXTMBearishPrev = mConditions.bars[mPrevIndex].high < mConditions.tms[mPrevIndex];
|
|
|
|
//
|
|
mConditions.isXTMNeutural = !mConditions.isXTMBullish && !mConditions.isXTMBearish;
|
|
bool isXTMNeuturalPrev = !isXTMBullishPrev && !isXTMBearishPrev;
|
|
|
|
//
|
|
mConditions.isXTMEndBullish =
|
|
//
|
|
!mConditions.isXTMBullish &&
|
|
isXTMBullishPrev
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXTMEndBearish =
|
|
//
|
|
!mConditions.isXTMBearish &&
|
|
isXTMBearishPrev
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXTMStartBullish =
|
|
//
|
|
mConditions.isXTMBullish &&
|
|
!isXTMBullishPrev
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXTMStartBearish =
|
|
//
|
|
mConditions.isXTMBearish &&
|
|
!isXTMBearishPrev
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXTMEndBullishByNeutural =
|
|
//
|
|
mConditions.isXTMNeutural &&
|
|
isXTMBullishPrev
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXTMEndBearishByNeutural =
|
|
//
|
|
mConditions.isXTMNeutural &&
|
|
isXTMBearishPrev
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXTMStartBullishAfterNeutural =
|
|
//
|
|
mConditions.isXTMBullish &&
|
|
isXTMNeuturalPrev
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXTMStartBearishAfterNeutural =
|
|
//
|
|
mConditions.isXTMBearish &&
|
|
isXTMNeuturalPrev
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
// XAMA ..
|
|
void CalculateAMAConditions(X5MarketConditions &mConditions)
|
|
{
|
|
//
|
|
int mIndex = 0;
|
|
int mPrevIndex = mIndex + 1;
|
|
int mLength = 10;
|
|
int mFrom = mIndex + mLength;
|
|
|
|
//
|
|
mConditions.isXAMAPeak = IsIncreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.amas);
|
|
|
|
//
|
|
mConditions.isXAMAVale = IsDecreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.amas);
|
|
|
|
//
|
|
mConditions.isXAMABullish = mConditions.bars[mIndex].low > mConditions.amas[mIndex];
|
|
bool isXAMABullishPrev = mConditions.bars[mPrevIndex].low > mConditions.amas[mPrevIndex];
|
|
|
|
//
|
|
mConditions.isXAMABearish = mConditions.bars[mIndex].high < mConditions.amas[mIndex];
|
|
bool isXAMABearishPrev = mConditions.bars[mPrevIndex].high < mConditions.amas[mPrevIndex];
|
|
|
|
//
|
|
mConditions.isXAMANeutural = !mConditions.isXAMABullish && !mConditions.isXAMABearish;
|
|
bool isXAMANeuturalPrev = !isXAMABullishPrev && !isXAMABearishPrev;
|
|
|
|
//
|
|
mConditions.isXAMAEndBullish =
|
|
//
|
|
!mConditions.isXAMABullish &&
|
|
isXAMABullishPrev
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXAMAEndBearish =
|
|
//
|
|
!mConditions.isXAMABearish &&
|
|
isXAMABearishPrev
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXAMAStartBullish =
|
|
//
|
|
mConditions.isXAMABullish &&
|
|
!isXAMABullishPrev
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXAMAStartBearish =
|
|
//
|
|
mConditions.isXAMABearish &&
|
|
!isXAMABearishPrev
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXAMAEndBullishByNeutural =
|
|
//
|
|
mConditions.isXAMANeutural &&
|
|
isXAMABullishPrev
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXAMAEndBearishByNeutural =
|
|
//
|
|
mConditions.isXAMANeutural &&
|
|
isXAMABearishPrev
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXAMAStartBullishAfterNeutural =
|
|
//
|
|
mConditions.isXAMABullish &&
|
|
isXAMANeuturalPrev
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXAMAStartBearishAfterNeutural =
|
|
//
|
|
mConditions.isXAMABearish &&
|
|
isXAMANeuturalPrev
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
// XFI ...
|
|
void CalculateFIConditions(X5MarketConditions &mConditions)
|
|
{
|
|
//
|
|
int mIndex = 0;
|
|
int mPrevIndex = mIndex + 1;
|
|
int mLength = 10;
|
|
int mFrom = mIndex + mLength;
|
|
|
|
//
|
|
mConditions.isXFIPeak = IsIncreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.fis);
|
|
|
|
//
|
|
mConditions.isXFIVale = IsDecreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.fis);
|
|
|
|
//
|
|
mConditions.isXFIOverZero = mConditions.fis[mIndex] > 0;
|
|
|
|
//
|
|
mConditions.isXFICrossedOverZero =
|
|
//
|
|
mConditions.isXFIOverZero &&
|
|
mConditions.fis[mPrevIndex] <= 0
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXFIUnderZero = mConditions.fis[mIndex] < 0;
|
|
|
|
//
|
|
mConditions.isXFICrossedUnderZero =
|
|
//
|
|
mConditions.isXFIUnderZero &&
|
|
mConditions.fis[mPrevIndex] >= 0
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
// XOBD ...
|
|
void CalculateOBDConditions(X5MarketConditions &mConditions)
|
|
{
|
|
//
|
|
int mIndex = 0;
|
|
int mPrevIndex = mIndex + 1;
|
|
int mLength = 10;
|
|
int mFrom = mIndex + mLength;
|
|
|
|
//
|
|
mConditions.isXOBDSwingLow = mConditions.obds[mIndex] == X_SWING_LOW;
|
|
mConditions.isXOBDSwingHigh = mConditions.obds[mIndex] == X_SWING_HIGH;
|
|
}
|
|
|
|
//
|
|
// XRSI ...
|
|
void CalculateRSIConditions(X5MarketConditions &mConditions)
|
|
{
|
|
//
|
|
int mIndex = 0;
|
|
int mPrevIndex = mIndex + 1;
|
|
int mLength = 10;
|
|
int mFrom = mIndex + mLength;
|
|
|
|
//
|
|
double shortEntryValue = mInputs.rsiInputs.shortEntryValue;
|
|
double shortExitValue = mInputs.rsiInputs.shortExitValue;
|
|
double longEntryValue = mInputs.rsiInputs.longEntryValue;
|
|
double longExitValue = mInputs.rsiInputs.longExitValue;
|
|
|
|
//
|
|
mConditions.isXRSIPeak = IsIncreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.rsis);
|
|
|
|
//
|
|
mConditions.isXRSIVale = IsDecreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.rsis);
|
|
|
|
//
|
|
mConditions.isXRSICrossedOverLongExit =
|
|
//
|
|
mConditions.rsis[mIndex] > longExitValue &&
|
|
mConditions.rsis[mPrevIndex] <= longExitValue;
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXRSICrossedOverLongEntry =
|
|
//
|
|
mConditions.rsis[mIndex] > longEntryValue &&
|
|
mConditions.rsis[mPrevIndex] <= longEntryValue;
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXRSICrossedUnderShortExit =
|
|
//
|
|
mConditions.rsis[mIndex] < shortExitValue &&
|
|
mConditions.rsis[mPrevIndex] >= shortExitValue;
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXRSICrossedUnderShortEntry =
|
|
//
|
|
mConditions.rsis[mIndex] < shortEntryValue &&
|
|
mConditions.rsis[mPrevIndex] >= shortEntryValue;
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
// XCHLH ...
|
|
void CalculateCHLHConditions(X5MarketConditions &mConditions)
|
|
{
|
|
//
|
|
int mIndex = 0;
|
|
int mPrevIndex = mIndex + 1;
|
|
int mLength = 10;
|
|
int mFrom = mIndex + mLength;
|
|
|
|
//
|
|
mConditions.isXCHLHSameHHs =
|
|
//
|
|
mConditions.chlhScHHs[mIndex] == mConditions.chlhMcHHs[mIndex] &&
|
|
mConditions.chlhMcHHs[mIndex] == mConditions.chlhLcHHs[mIndex]
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXCHLHSameLLs =
|
|
//
|
|
mConditions.chlhScLLs[mIndex] == mConditions.chlhMcLLs[mIndex] &&
|
|
mConditions.chlhMcLLs[mIndex] == mConditions.chlhLcLLs[mIndex]
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXCHLHSCMCHHSame =
|
|
//
|
|
mConditions.chlhScHHs[mIndex] == mConditions.chlhMcHHs[mIndex]
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXCHLHSCMCLLSame =
|
|
//
|
|
mConditions.chlhScLLs[mIndex] == mConditions.chlhMcLLs[mIndex]
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXCHLHSCLCHHSame =
|
|
//
|
|
mConditions.chlhScHHs[mIndex] == mConditions.chlhLcLLs[mIndex]
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXCHLHSCLCLLSame =
|
|
//
|
|
mConditions.chlhScLLs[mIndex] == mConditions.chlhLcLLs[mIndex]
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXCHLHMCLCHHSame =
|
|
//
|
|
mConditions.chlhMcHHs[mIndex] == mConditions.chlhLcHHs[mIndex]
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXCHLHMCLCLLSame =
|
|
//
|
|
mConditions.chlhMcLLs[mIndex] == mConditions.chlhLcLLs[mIndex]
|
|
//
|
|
;
|
|
|
|
// //
|
|
// isXCHLHMCOnTopOfLC =
|
|
// //
|
|
// //
|
|
// ;
|
|
|
|
// //
|
|
// isXCHLHMCInBottomOfLC =
|
|
// //
|
|
// //
|
|
// ;
|
|
}
|
|
|
|
//
|
|
// XLH ...
|
|
void CalculateLHConditions(X5MarketConditions &mConditions)
|
|
{
|
|
//
|
|
int mIndex = 0;
|
|
int mPrevIndex = mIndex + 1;
|
|
int mLength = 10;
|
|
int mFrom = mIndex + mLength;
|
|
|
|
//
|
|
mConditions.isXLHHHIncreased = IsIncreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.lhHhs);
|
|
|
|
//
|
|
mConditions.isXLHHHDecreased = IsDecreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.lhHhs);
|
|
|
|
//
|
|
mConditions.isXLHLLIncreased = IsIncreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.lhLls);
|
|
|
|
//
|
|
mConditions.isXLHLLDecreased = IsDecreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.lhLls);
|
|
|
|
//
|
|
mConditions.isXLHLowAttachedLL = mConditions.bars[mIndex].low == mConditions.lhLls[mIndex];
|
|
|
|
//
|
|
mConditions.isXLHHighAttachedHH = mConditions.bars[mIndex].high == mConditions.lhHhs[mIndex];
|
|
;
|
|
|
|
//
|
|
mConditions.isXLHHHSameInLength = IsSame(mConditions.lhHhs);
|
|
|
|
//
|
|
mConditions.isXLHLLSameInLength = IsSame(mConditions.lhLls);
|
|
|
|
//
|
|
mConditions.isXLHPriceOverSignal = mConditions.bars[mIndex].low > mConditions.lhSignals[mIndex];
|
|
|
|
//
|
|
mConditions.isXLHPriceUnderSignal = mConditions.bars[mIndex].high < mConditions.lhSignals[mIndex];
|
|
|
|
//
|
|
mConditions.isXLHPriceInSignalRange = !mConditions.isXLHPriceOverSignal && !mConditions.isXLHPriceUnderSignal;
|
|
|
|
//
|
|
mConditions.isXLHPriceCrossedOverSignal =
|
|
//
|
|
mConditions.isXLHPriceOverSignal &&
|
|
!(mConditions.bars[mPrevIndex].low > mConditions.lhSignals[mPrevIndex])
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXLHPriceCrossedUnderSignal =
|
|
//
|
|
mConditions.isXLHPriceUnderSignal &&
|
|
!(mConditions.bars[mIndex].high < mConditions.lhSignals[mIndex])
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
// XTD ...
|
|
void CalculateTDConditions(X5MarketConditions &mConditions)
|
|
{
|
|
//
|
|
int mIndex = 0;
|
|
int mPrevIndex = mIndex + 1;
|
|
int mLength = 10;
|
|
int mFrom = mIndex + mLength;
|
|
|
|
//
|
|
mConditions.isXTDSignalPeak = IsIncreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.tdSignals);
|
|
|
|
//
|
|
mConditions.isXTDSignalVale = IsDecreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.tdSignals);
|
|
|
|
//
|
|
mConditions.isXTDBullishPeak = IsIncreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.tdBullishs);
|
|
|
|
//
|
|
mConditions.isXTDBullishVale = IsDecreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.tdBullishs);
|
|
|
|
//
|
|
mConditions.isXTDBearishPeak = IsIncreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.tdBearishs);
|
|
|
|
//
|
|
mConditions.isXTDBearishVale = IsDecreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.tdBearishs);
|
|
|
|
//
|
|
mConditions.isXTDBullOverBear = mConditions.tdBullishs[mIndex] > mConditions.tdBearishs[mIndex];
|
|
bool isXTDBullOverBearPrev = mConditions.tdBullishs[mPrevIndex] > mConditions.tdBearishs[mPrevIndex];
|
|
|
|
//
|
|
mConditions.isXTDBullUnderBear = mConditions.tdBullishs[mIndex] < mConditions.tdBearishs[mIndex];
|
|
bool isXTDBullUnderBearPrev = mConditions.tdBullishs[mPrevIndex] < mConditions.tdBearishs[mPrevIndex];
|
|
|
|
//
|
|
mConditions.isXTDSignalOverBear = mConditions.tdSignals[mIndex] > mConditions.tdBearishs[mIndex];
|
|
bool isXTDSignalOverBearPrev = mConditions.tdSignals[mPrevIndex] > mConditions.tdBearishs[mPrevIndex];
|
|
|
|
//
|
|
mConditions.isXTDSignalUnderBear = mConditions.tdSignals[mIndex] < mConditions.tdBearishs[mIndex];
|
|
bool isXTDSignalUnderBearPrev = mConditions.tdSignals[mPrevIndex] < mConditions.tdBearishs[mPrevIndex];
|
|
|
|
//
|
|
mConditions.isXTDBullCrossedOverBear =
|
|
mConditions.isXTDBullOverBear &&
|
|
!isXTDBullOverBearPrev;
|
|
|
|
//
|
|
mConditions.isXTDBullCrossedUnderBear =
|
|
mConditions.isXTDBullUnderBear &&
|
|
!isXTDBullUnderBearPrev;
|
|
|
|
//
|
|
mConditions.isXTDSignalCrossedOverBear =
|
|
mConditions.isXTDSignalOverBear &&
|
|
!isXTDSignalOverBearPrev;
|
|
|
|
//
|
|
mConditions.isXTDSignalCrossedUnderBear =
|
|
mConditions.isXTDSignalUnderBear &&
|
|
!isXTDSignalUnderBearPrev;
|
|
}
|
|
|
|
//
|
|
// XTS ...
|
|
void CalculateTSConditions(X5MarketConditions &mConditions)
|
|
{
|
|
//
|
|
int mIndex = 0;
|
|
int mPrevIndex = mIndex + 1;
|
|
int mLength = 10;
|
|
int mFrom = mIndex + mLength;
|
|
|
|
//
|
|
double current = mConditions.tsCurrents[mIndex];
|
|
double currentPrev = mConditions.tsCurrents[mPrevIndex];
|
|
|
|
//
|
|
double nearest = mConditions.tsNearests[mIndex];
|
|
double nearestPrev = mConditions.tsNearests[mPrevIndex];
|
|
|
|
//
|
|
double mediest = mConditions.tsMediests[mIndex];
|
|
double mediestPrev = mConditions.tsMediests[mPrevIndex];
|
|
|
|
//
|
|
double farest = mConditions.tsFarests[mIndex];
|
|
double farestPrev = mConditions.tsFarests[mPrevIndex];
|
|
|
|
//
|
|
double tsValues[] = {current, nearest, mediest, farest};
|
|
double tsMax = GetMax(tsValues);
|
|
double tsMin = GetMin(tsValues);
|
|
|
|
//
|
|
double tsPrevValues[] = {currentPrev, nearestPrev, mediestPrev, farestPrev};
|
|
double tsPrevMax = GetMax(tsPrevValues);
|
|
double tsPrevMin = GetMin(tsPrevValues);
|
|
|
|
//
|
|
mConditions.isXTSAllSame =
|
|
//
|
|
current == nearest &&
|
|
nearest == mediest &&
|
|
mediest == farest
|
|
//
|
|
;
|
|
|
|
//
|
|
mConditions.isXTSCurrentMin = current == tsMin;
|
|
mConditions.isXTSCurrentMax = current == tsMax;
|
|
|
|
//
|
|
mConditions.isXTSCurrentOverFarest = current > farest;
|
|
bool isXTSCurrentOverFarestPrev = currentPrev > farestPrev;
|
|
|
|
//
|
|
mConditions.isXTSCurrentOverNearest = current > nearest;
|
|
bool isXTSCurrentOverNearestPrev = currentPrev > nearestPrev;
|
|
|
|
//
|
|
mConditions.isXTSCurrentOverMediest = current > mediest;
|
|
bool isXTSCurrentOverMediestPrev = currentPrev > mediestPrev;
|
|
|
|
//
|
|
mConditions.isXTSCurrentUnderFarest = current < farest;
|
|
bool isXTSCurrentUnderFarestPrev = currentPrev < farestPrev;
|
|
|
|
//
|
|
mConditions.isXTSCurrentUnderNearest = current < nearest;
|
|
bool isXTSCurrentUnderNearestPrev = currentPrev < nearestPrev;
|
|
|
|
//
|
|
mConditions.isXTSCurrentUnderMediest = current < mediest;
|
|
bool isXTSCurrentUnderMediestPrev = currentPrev < mediestPrev;
|
|
|
|
//
|
|
mConditions.isXTSCurrentCrossedOverFarest =
|
|
mConditions.isXTSCurrentOverFarest &&
|
|
!isXTSCurrentOverFarestPrev;
|
|
|
|
//
|
|
mConditions.isXTSCurrentCrossedOverNearest =
|
|
mConditions.isXTSCurrentOverNearest &&
|
|
!isXTSCurrentOverNearestPrev;
|
|
|
|
//
|
|
mConditions.isXTSCurrentCrossedOverMediest =
|
|
mConditions.isXTSCurrentOverMediest &&
|
|
!isXTSCurrentOverMediestPrev;
|
|
|
|
//
|
|
mConditions.isXTSCurrentCrossedUnderFarest =
|
|
mConditions.isXTSCurrentUnderFarest &&
|
|
!isXTSCurrentUnderFarestPrev;
|
|
|
|
//
|
|
mConditions.isXTSCurrentCrossedUnderNearest =
|
|
mConditions.isXTSCurrentUnderNearest &&
|
|
!isXTSCurrentUnderNearestPrev;
|
|
|
|
//
|
|
mConditions.isXTSCurrentCrossedUnderMediest =
|
|
mConditions.isXTSCurrentUnderMediest &&
|
|
!isXTSCurrentUnderMediestPrev;
|
|
}
|
|
|
|
//
|
|
// XCHMA ...
|
|
void CalculateCHMAConditions(X5MarketConditions &mConditions)
|
|
{
|
|
//
|
|
int mIndex = 0;
|
|
int mPrevIndex = mIndex + 1;
|
|
int mLength = 10;
|
|
int mFrom = mIndex + mLength;
|
|
|
|
//
|
|
double scFast = mConditions.chmaScFasts[mIndex];
|
|
double scSlow = mConditions.chmaScSlows[mIndex];
|
|
double scFastPrev = mConditions.chmaScFasts[mPrevIndex];
|
|
double scSlowPrev = mConditions.chmaScSlows[mPrevIndex];
|
|
|
|
//
|
|
double mcFast = mConditions.chmaMcFasts[mIndex];
|
|
double mcSlow = mConditions.chmaMcSlows[mIndex];
|
|
double mcFastPrev = mConditions.chmaMcFasts[mPrevIndex];
|
|
double mcSlowPrev = mConditions.chmaMcSlows[mPrevIndex];
|
|
|
|
//
|
|
double lcFast = mConditions.chmaLcFasts[mIndex];
|
|
double lcSlow = mConditions.chmaLcSlows[mIndex];
|
|
double lcFastPrev = mConditions.chmaLcFasts[mPrevIndex];
|
|
double lcSlowPrev = mConditions.chmaLcSlows[mPrevIndex];
|
|
|
|
//
|
|
double chmaValues[] = {
|
|
scFast,
|
|
scSlow,
|
|
mcFast,
|
|
mcSlow,
|
|
lcFast,
|
|
lcSlow};
|
|
double chmaNonSCValues[] = {
|
|
mcFast,
|
|
mcSlow,
|
|
lcFast,
|
|
lcSlow};
|
|
double chmaMin = GetMin(chmaValues);
|
|
double chmaMax = GetMax(chmaValues);
|
|
double chmaNonSCMin = GetMin(chmaNonSCValues);
|
|
double chmaNonSCMax = GetMax(chmaNonSCValues);
|
|
|
|
//
|
|
double chmaValuesPrev[] = {
|
|
scFastPrev,
|
|
scSlowPrev,
|
|
mcFastPrev,
|
|
mcSlowPrev,
|
|
lcFastPrev,
|
|
lcSlowPrev};
|
|
double chmaNonSCValuesPrev[] = {
|
|
mcFastPrev,
|
|
mcSlowPrev,
|
|
lcFastPrev,
|
|
lcSlowPrev};
|
|
double chmaMinPrev = GetMin(chmaValuesPrev);
|
|
double chmaMaxPrev = GetMax(chmaValuesPrev);
|
|
double chmaNonSCMinPrev = GetMin(chmaNonSCValuesPrev);
|
|
double chmaNonSCMaxPrev = GetMax(chmaNonSCValuesPrev);
|
|
|
|
//
|
|
mConditions.isXCHMASCOverMax = MathMin(scFast, scSlow) > chmaNonSCMax;
|
|
bool isXCHMASCOverMaxPrev = MathMin(scFastPrev, scSlowPrev) > chmaNonSCMaxPrev;
|
|
|
|
//
|
|
mConditions.isXCHMASCOverMin = MathMin(scFast, scSlow) > chmaNonSCMin;
|
|
bool isXCHMASCOverMinPrev = MathMin(scFastPrev, scSlowPrev) > chmaNonSCMinPrev;
|
|
|
|
//
|
|
mConditions.isXCHMASCUnderMax = MathMax(scFast, scSlow) < chmaNonSCMax;
|
|
bool isXCHMASCUnderMaxPrev = MathMax(scFastPrev, scSlowPrev) < chmaNonSCMaxPrev;
|
|
|
|
//
|
|
mConditions.isXCHMASCUnderMin = MathMax(scFast, scSlow) < chmaNonSCMin;
|
|
bool isXCHMASCUnderMinPrev = MathMax(scFastPrev, scSlowPrev) < chmaNonSCMinPrev;
|
|
|
|
//
|
|
mConditions.isXCHMASCCrossedOverMax =
|
|
mConditions.isXCHMASCOverMax &&
|
|
!isXCHMASCOverMaxPrev;
|
|
|
|
//
|
|
mConditions.isXCHMASCCrossedUnderMax =
|
|
mConditions.isXCHMASCUnderMax &&
|
|
!isXCHMASCUnderMaxPrev;
|
|
|
|
//
|
|
mConditions.isXCHMASCCrossedOverMin =
|
|
mConditions.isXCHMASCOverMin &&
|
|
!isXCHMASCOverMinPrev;
|
|
|
|
//
|
|
mConditions.isXCHMASCCrossedUnderMin =
|
|
mConditions.isXCHMASCUnderMin &&
|
|
!isXCHMASCUnderMinPrev;
|
|
|
|
//
|
|
// Short ...
|
|
|
|
//
|
|
mConditions.isXCHMASCPeak = IsIncreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.chmaScFasts);
|
|
|
|
//
|
|
mConditions.isXCHMASCVale = IsDecreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.chmaScFasts);
|
|
|
|
//
|
|
mConditions.isXCHMASCTrendsUp = IsTrendingUp(
|
|
mConditions.chmaScFasts,
|
|
mConditions.chmaScSlows);
|
|
|
|
//
|
|
mConditions.isXCHMASCTrendsDown = IsTrendingDown(
|
|
mConditions.chmaScFasts,
|
|
mConditions.chmaScSlows);
|
|
|
|
//
|
|
mConditions.isXCHMASCFastOverSlow = scFast > scSlow;
|
|
bool isXCHMASCFastOverSlowPrev = scFastPrev > scSlowPrev;
|
|
|
|
//
|
|
mConditions.isXCHMASCFastUnderSlow = scFast < scSlow;
|
|
bool isXCHMASCFastUnderSlowPrev = scFastPrev < scSlowPrev;
|
|
|
|
//
|
|
mConditions.isXCHMASCFastCrossedOverSlow =
|
|
mConditions.isXCHMASCFastOverSlow &&
|
|
!isXCHMASCFastOverSlowPrev;
|
|
|
|
//
|
|
mConditions.isXCHMASCFastCrossedUnderSlow =
|
|
mConditions.isXCHMASCFastUnderSlow &&
|
|
!isXCHMASCFastUnderSlowPrev;
|
|
|
|
//
|
|
// Medium ...
|
|
|
|
//
|
|
mConditions.isXCHMAMCPeak = IsIncreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.chmaMcFasts);
|
|
|
|
//
|
|
mConditions.isXCHMAMCVale = IsDecreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.chmaMcFasts);
|
|
|
|
//
|
|
mConditions.isXCHMAMCTrendsUp = IsTrendingUp(
|
|
mConditions.chmaMcFasts,
|
|
mConditions.chmaMcSlows);
|
|
|
|
//
|
|
mConditions.isXCHMAMCTrendsDown = IsTrendingDown(
|
|
mConditions.chmaMcFasts,
|
|
mConditions.chmaMcSlows);
|
|
|
|
//
|
|
mConditions.isXCHMAMCFastOverSlow = mcFast > mcSlow;
|
|
bool isXCHMAMCFastOverSlowPrev = mcFastPrev > mcSlowPrev;
|
|
|
|
//
|
|
mConditions.isXCHMAMCFastUnderSlow = mcFast < mcSlow;
|
|
bool isXCHMAMCFastUnderSlowPrev = mcFastPrev < mcSlowPrev;
|
|
|
|
//
|
|
mConditions.isXCHMAMCFastCrossedOverSlow =
|
|
mConditions.isXCHMAMCFastOverSlow &&
|
|
!isXCHMAMCFastOverSlowPrev;
|
|
|
|
//
|
|
mConditions.isXCHMAMCFastCrossedUnderSlow =
|
|
mConditions.isXCHMAMCFastUnderSlow &&
|
|
!isXCHMAMCFastUnderSlowPrev;
|
|
|
|
//
|
|
// Long ...
|
|
|
|
//
|
|
mConditions.isXCHMALCPeak = IsIncreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.chmaLcFasts);
|
|
|
|
//
|
|
mConditions.isXCHMALCVale = IsDecreasing(
|
|
mFrom,
|
|
mIndex,
|
|
mConditions.chmaLcFasts);
|
|
|
|
//
|
|
mConditions.isXCHMALCTrendsUp = IsTrendingUp(
|
|
mConditions.chmaLcFasts,
|
|
mConditions.chmaLcSlows);
|
|
|
|
//
|
|
mConditions.isXCHMALCTrendsDown = IsTrendingDown(
|
|
mConditions.chmaMcFasts,
|
|
mConditions.chmaMcSlows);
|
|
|
|
//
|
|
mConditions.isXCHMALCFastOverSlow = lcFast > lcSlow;
|
|
bool isXCHMALCFastOverSlowPrev = lcFastPrev > lcSlowPrev;
|
|
|
|
//
|
|
mConditions.isXCHMALCFastUnderSlow = lcFast < lcSlow;
|
|
bool isXCHMALCFastUnderSlowPrev = lcFastPrev < lcSlowPrev;
|
|
|
|
//
|
|
mConditions.isXCHMALCFastCrossedOverSlow =
|
|
mConditions.isXCHMALCFastOverSlow &&
|
|
!isXCHMALCFastOverSlowPrev;
|
|
|
|
//
|
|
mConditions.isXCHMALCFastCrossedUnderSlow =
|
|
mConditions.isXCHMALCFastUnderSlow &&
|
|
!isXCHMALCFastUnderSlowPrev;
|
|
}
|
|
};
|