3025 lines
77 KiB
Plaintext
3025 lines
77 KiB
Plaintext
///////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 Helper Class Library
|
|
// ----------------------------------------------
|
|
// Name: XCXCAEAHelper
|
|
// 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-bar.analyser.class.mq5"
|
|
#include "../../Classes/x-saherelm.x-poi.class.mq5"
|
|
#include "../../Classes/x-saherelm.x-poi.drawer.class.mq5"
|
|
#include "../../Helpers/x-saherelm.x121.xca.helper.mq5"
|
|
#include "../../Helpers/x-saherelm.x121.xcc.helper.mq5"
|
|
#include "../../Helpers/x-saherelm.x121.xct.helper.mq5"
|
|
#include "../../Helpers/x-saherelm.x121.xoscs.helper.mq5"
|
|
|
|
//
|
|
// Input Structure ...
|
|
struct XCAEAInputs
|
|
{
|
|
//
|
|
bool showAC;
|
|
bool showAD;
|
|
bool showADX;
|
|
bool showATR;
|
|
bool showCCI;
|
|
bool showRSI;
|
|
bool showMFI;
|
|
bool showRVI;
|
|
bool showMACD;
|
|
bool showMomentum;
|
|
bool showStochastic;
|
|
|
|
//
|
|
X121XCTInputs ctInputs;
|
|
X121XCCInputs ccInputs;
|
|
X121XCAInputs caInputs;
|
|
X121XOCSInputs oscsInputs;
|
|
|
|
//
|
|
// Constructor ...
|
|
XCAEAInputs()
|
|
{
|
|
Clean();
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Cleaning Up ...
|
|
*/
|
|
void Clean()
|
|
{
|
|
//
|
|
showAC = false;
|
|
showAD = false;
|
|
showADX = false;
|
|
showATR = false;
|
|
showCCI = false;
|
|
showRSI = false;
|
|
showMFI = false;
|
|
showRVI = false;
|
|
showMACD = false;
|
|
showMomentum = false;
|
|
showStochastic = false;
|
|
|
|
//
|
|
ctInputs.Clean();
|
|
ccInputs.Clean();
|
|
caInputs.Clean();
|
|
oscsInputs.Clean();
|
|
|
|
//
|
|
ZeroMemory(this);
|
|
}
|
|
|
|
/**
|
|
* Set Default Values ...
|
|
*/
|
|
void Default()
|
|
{
|
|
//
|
|
ctInputs.Default();
|
|
ccInputs.Default();
|
|
caInputs.Default();
|
|
oscsInputs.Default();
|
|
}
|
|
|
|
/**
|
|
* Validate ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsValid()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
ctInputs.IsValid() &&
|
|
ccInputs.IsValid() &&
|
|
caInputs.IsValid() &&
|
|
oscsInputs.IsValid()
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Extract Max Input Length ...
|
|
*
|
|
* @return ( int )
|
|
*/
|
|
int Max()
|
|
{
|
|
//
|
|
int result = 0;
|
|
|
|
//
|
|
int ctMax = ctInputs.Max();
|
|
int ccMax = ccInputs.Max();
|
|
int caMax = caInputs.Max();
|
|
int ocsMax = oscsInputs.Max();
|
|
|
|
//
|
|
result = MathMax(ctMax, ccMax);
|
|
result = MathMax(result, caMax);
|
|
result = MathMax(result, ocsMax);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
};
|
|
|
|
//
|
|
// Conditions Structure ...
|
|
struct XCAEAConditions
|
|
{
|
|
//
|
|
// Common ...
|
|
string symbol;
|
|
ENUM_TIMEFRAMES period;
|
|
datetime time;
|
|
|
|
//
|
|
datetime to;
|
|
datetime from;
|
|
|
|
//
|
|
// XCA ...
|
|
|
|
//
|
|
// Buffers ...
|
|
|
|
//
|
|
double kiBuffer[];
|
|
double tkiBuffer[];
|
|
double sHHBuffer[];
|
|
double sLLBuffer[];
|
|
double mHHBuffer[];
|
|
double mLLBuffer[];
|
|
double lHHBuffer[];
|
|
double lLLBuffer[];
|
|
double hHHBuffer[];
|
|
double hLLBuffer[];
|
|
double sarBuffer[];
|
|
double peakBuffer[];
|
|
double valeBuffer[];
|
|
double trendBuffer[];
|
|
double kiStateBuffer[];
|
|
double supportBuffer[];
|
|
double tkiStateBuffer[];
|
|
double swingLowBuffer[];
|
|
double swingHighBuffer[];
|
|
double resistanceBuffer[];
|
|
double peakGoldenBuffer[];
|
|
double valeGoldenBuffer[];
|
|
double fiboLevel1Buffer[];
|
|
double fiboLevel2Buffer[];
|
|
double fiboLevel3Buffer[];
|
|
double trendStateBuffer[];
|
|
|
|
//
|
|
// Conditions ...
|
|
|
|
//
|
|
// KI ...
|
|
|
|
//
|
|
bool isKIRejectUp;
|
|
bool isKIRejectDown;
|
|
|
|
//
|
|
bool isKIBullish;
|
|
bool isKIBearish;
|
|
|
|
//
|
|
bool isKISwitchedToBullish;
|
|
bool isKISwitchedToBearish;
|
|
|
|
//
|
|
// TKI ...
|
|
|
|
//
|
|
bool isTKIRejectUp;
|
|
bool isTKIRejectDown;
|
|
|
|
//
|
|
bool isTKIBullish;
|
|
bool isTKIBearish;
|
|
|
|
//
|
|
bool isTKISwitchedToBullish;
|
|
bool isTKISwitchedToBearish;
|
|
|
|
//
|
|
// SAR ...
|
|
|
|
//
|
|
bool isSarBullish;
|
|
bool isSarBearish;
|
|
|
|
//
|
|
bool isSarSwitchedToBullish;
|
|
bool isSarSwitchedToBearish;
|
|
|
|
//
|
|
// PEAK ...
|
|
|
|
//
|
|
bool isPeakSameLast;
|
|
bool isPeakOverLast;
|
|
bool isPeakUnderLast;
|
|
|
|
//
|
|
// VALE ...
|
|
|
|
//
|
|
bool isValeSameLast;
|
|
bool isValeOverLast;
|
|
bool isValeUnderLast;
|
|
|
|
//
|
|
// TREND ...
|
|
|
|
//
|
|
bool isTrendRejectUp;
|
|
bool isTrendRejectDown;
|
|
|
|
//
|
|
bool isTrendBullish;
|
|
bool isTrendBearish;
|
|
|
|
//
|
|
bool isTrendSwitchedToBullish;
|
|
bool isTrendSwitchedToBearish;
|
|
|
|
//
|
|
// SUPPORT ...
|
|
|
|
//
|
|
bool isSupportSameLast;
|
|
bool isSupportOverLast;
|
|
bool isSupportUnderLast;
|
|
|
|
//
|
|
bool isLastSupportBreaked;
|
|
bool isLastSupportRejected;
|
|
|
|
//
|
|
// RESISTANCE ...
|
|
|
|
//
|
|
bool isResistanceSameLast;
|
|
bool isResistanceOverLast;
|
|
bool isResistanceUnderLast;
|
|
|
|
//
|
|
bool isLastResistanceBreaked;
|
|
bool isLastResistanceRejected;
|
|
|
|
//
|
|
// SWING Low ...
|
|
|
|
//
|
|
bool isSwingLowSameLast;
|
|
bool isSwingLowOverLast;
|
|
bool isSwingLowUnderLast;
|
|
|
|
//
|
|
bool isLastSwingLowBreaked;
|
|
bool isLastSwingLowRejected;
|
|
|
|
//
|
|
// SWING High ...
|
|
|
|
//
|
|
bool isSwingHighSameLast;
|
|
bool isSwingHighOverLast;
|
|
bool isSwingHighUnderLast;
|
|
|
|
//
|
|
bool isLastSwingHighBreaked;
|
|
bool isLastSwingHighRejected;
|
|
|
|
//
|
|
// COMPLEX Conditions ...
|
|
|
|
//
|
|
bool isPeakIsPivot;
|
|
bool isValeIsPivot;
|
|
|
|
//
|
|
bool isSwingLowSameAsVale;
|
|
bool isSwingHighSameAsPeak;
|
|
|
|
//
|
|
bool isSupportSameAsVale;
|
|
bool isResistanceSameAsPeak;
|
|
|
|
//
|
|
bool isSupportSameAsSwingLow;
|
|
bool isResistanceSameAsSwingHigh;
|
|
|
|
//
|
|
// XOSCS ...
|
|
|
|
//
|
|
// Buffers ...
|
|
|
|
//
|
|
double acBuffer[];
|
|
double adBuffer[];
|
|
double atrBuffer[];
|
|
double cciBuffer[];
|
|
double rsiBuffer[];
|
|
double mfiBuffer[];
|
|
double rviBuffer[];
|
|
double adxBuffer[];
|
|
double adxpBuffer[];
|
|
double adxnBuffer[];
|
|
double macdBuffer[];
|
|
double momentumBuffer[];
|
|
double rviSignalBuffer[];
|
|
double macdSignalBuffer[];
|
|
double stochasticBuffer[];
|
|
double stochasticSignalBuffer[];
|
|
|
|
//
|
|
// Conditions ...
|
|
|
|
//
|
|
// AC ...
|
|
|
|
//
|
|
bool isACBullish;
|
|
bool isACBearish;
|
|
|
|
//
|
|
bool isACSwitchedToBullish;
|
|
bool isACSwitchedToBearish;
|
|
|
|
//
|
|
bool isACOverMax;
|
|
bool isACUnderMin;
|
|
|
|
//
|
|
// AD ...
|
|
|
|
//
|
|
bool isADBiggerLast;
|
|
bool isADLesserLast;
|
|
|
|
//
|
|
bool isADOverMax;
|
|
bool isADUnderMin;
|
|
|
|
//
|
|
// ADX ...
|
|
|
|
//
|
|
bool isADXBiggerLast;
|
|
bool isADXLesserLast;
|
|
|
|
//
|
|
bool isADXOverThreshold;
|
|
bool isADXUnderThreshold;
|
|
|
|
//
|
|
bool isDXPBiggerThanDXN;
|
|
bool isDXNBiggerThanDXP;
|
|
|
|
//
|
|
bool isADXBullish;
|
|
bool isADXBearish;
|
|
|
|
//
|
|
bool isADXSwitchedToBullish;
|
|
bool isADXSwitchedToBearish;
|
|
|
|
//
|
|
// ATR ...
|
|
|
|
bool isATROverLast;
|
|
bool isATRUnderLast;
|
|
|
|
//
|
|
// CCI ...
|
|
|
|
//
|
|
bool isCCIBullish;
|
|
bool isCCIBearish;
|
|
|
|
//
|
|
bool isCCISwitchedToBullish;
|
|
bool isCCISwitchedToBearish;
|
|
|
|
//
|
|
bool isCCIOB;
|
|
bool isCCIOS;
|
|
|
|
//
|
|
bool isCCICrossedOverOB;
|
|
bool isCCICrossedOverOS;
|
|
|
|
//
|
|
bool isCCICrossedUnderOB;
|
|
bool isCCICrossedUnderOS;
|
|
|
|
//
|
|
// RSI ...
|
|
|
|
//
|
|
bool isRSIBullish;
|
|
bool isRSIBearish;
|
|
|
|
//
|
|
bool isRSISwitchedToBullish;
|
|
bool isRSISwitchedToBearish;
|
|
|
|
//
|
|
bool isRSIOB;
|
|
bool isRSIOS;
|
|
|
|
//
|
|
bool isRSICrossedOverOB;
|
|
bool isRSICrossedOverOS;
|
|
|
|
//
|
|
bool isRSICrossedUnderOB;
|
|
bool isRSICrossedUnderOS;
|
|
|
|
//
|
|
// MFI ...
|
|
|
|
//
|
|
bool isMFIBullish;
|
|
bool isMFIBearish;
|
|
|
|
//
|
|
bool isMFISwitchedToBullish;
|
|
bool isMFISwitchedToBearish;
|
|
|
|
//
|
|
bool isMFIOB;
|
|
bool isMFIOS;
|
|
|
|
//
|
|
bool isMFICrossedOverOB;
|
|
bool isMFICrossedOverOS;
|
|
|
|
//
|
|
bool isMFICrossedUnderOB;
|
|
bool isMFICrossedUnderOS;
|
|
|
|
//
|
|
// RVI ...
|
|
|
|
//
|
|
bool isRVIBullish;
|
|
bool isRVIBearish;
|
|
|
|
//
|
|
bool isRVISwitchedToBullish;
|
|
bool isRVISwitchedToBearish;
|
|
|
|
//
|
|
bool isRVIOverSignal;
|
|
bool isRVIUnderSignal;
|
|
|
|
//
|
|
bool isRVICrossedOverSignal;
|
|
bool isRVICrossedUnderSignal;
|
|
|
|
//
|
|
// MACD ...
|
|
|
|
//
|
|
bool isMACDBullish;
|
|
bool isMACDBearish;
|
|
|
|
//
|
|
bool isMACDSwitchedToBullish;
|
|
bool isMACDSwitchedToBearish;
|
|
|
|
//
|
|
bool isMACDOverSignal;
|
|
bool isMACDUnderSignal;
|
|
|
|
//
|
|
bool isMACDCrossedOverSignal;
|
|
bool isMACDCrossedUnderSignal;
|
|
|
|
//
|
|
// MOMENTUM ...
|
|
|
|
//
|
|
bool isMomentumBullish;
|
|
bool isMomentumBearish;
|
|
|
|
//
|
|
bool isMomentumSwitchedToBullish;
|
|
bool isMomentumSwitchedToBearish;
|
|
|
|
//
|
|
// STOCHASTIC ...
|
|
|
|
//
|
|
bool isStochasticBullish;
|
|
bool isStochasticBearish;
|
|
|
|
//
|
|
bool isStochasticSwitchedToBullish;
|
|
bool isStochasticSwitchedToBearish;
|
|
|
|
//
|
|
bool isStochasticOverSignal;
|
|
bool isStochasticUnderSignal;
|
|
|
|
//
|
|
bool isStochasticCrossedOverSignal;
|
|
bool isStochasticCrossedUnderSignal;
|
|
|
|
//
|
|
bool isStochasticOB;
|
|
bool isStochasticOS;
|
|
|
|
//
|
|
bool isStochasticCrossedOverOB;
|
|
bool isStochasticCrossedOverOS;
|
|
|
|
//
|
|
bool isStochasticCrossedUnderOB;
|
|
bool isStochasticCrossedUnderOS;
|
|
|
|
//
|
|
// Specified Conditions ...
|
|
|
|
//
|
|
|
|
//
|
|
// Constructor ...
|
|
XCAEAConditions()
|
|
{
|
|
Clean();
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Cleaning Up ...
|
|
*/
|
|
void Clean()
|
|
{
|
|
//
|
|
// Commons ...
|
|
symbol = NULL;
|
|
period = NULL;
|
|
|
|
//
|
|
to = NULL;
|
|
from = NULL;
|
|
time = NULL;
|
|
|
|
//
|
|
// XCA ...
|
|
|
|
//
|
|
// Buffers ...
|
|
|
|
//
|
|
Clean(kiBuffer);
|
|
Clean(tkiBuffer);
|
|
Clean(sHHBuffer);
|
|
Clean(sLLBuffer);
|
|
Clean(mHHBuffer);
|
|
Clean(mLLBuffer);
|
|
Clean(lHHBuffer);
|
|
Clean(lLLBuffer);
|
|
Clean(hHHBuffer);
|
|
Clean(hLLBuffer);
|
|
Clean(sarBuffer);
|
|
Clean(peakBuffer);
|
|
Clean(valeBuffer);
|
|
Clean(trendBuffer);
|
|
Clean(kiStateBuffer);
|
|
Clean(supportBuffer);
|
|
Clean(tkiStateBuffer);
|
|
Clean(swingLowBuffer);
|
|
Clean(swingHighBuffer);
|
|
Clean(resistanceBuffer);
|
|
Clean(peakGoldenBuffer);
|
|
Clean(valeGoldenBuffer);
|
|
Clean(fiboLevel1Buffer);
|
|
Clean(fiboLevel2Buffer);
|
|
Clean(fiboLevel3Buffer);
|
|
Clean(trendStateBuffer);
|
|
|
|
//
|
|
ArraySetAsSeries(kiBuffer, true);
|
|
ArraySetAsSeries(tkiBuffer, 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(sarBuffer, true);
|
|
ArraySetAsSeries(peakBuffer, true);
|
|
ArraySetAsSeries(valeBuffer, true);
|
|
ArraySetAsSeries(trendBuffer, true);
|
|
ArraySetAsSeries(kiStateBuffer, true);
|
|
ArraySetAsSeries(supportBuffer, true);
|
|
ArraySetAsSeries(tkiStateBuffer, true);
|
|
ArraySetAsSeries(swingLowBuffer, true);
|
|
ArraySetAsSeries(swingHighBuffer, true);
|
|
ArraySetAsSeries(resistanceBuffer, true);
|
|
ArraySetAsSeries(peakGoldenBuffer, true);
|
|
ArraySetAsSeries(valeGoldenBuffer, true);
|
|
ArraySetAsSeries(fiboLevel1Buffer, true);
|
|
ArraySetAsSeries(fiboLevel2Buffer, true);
|
|
ArraySetAsSeries(fiboLevel3Buffer, true);
|
|
ArraySetAsSeries(trendStateBuffer, true);
|
|
|
|
//
|
|
// Conditions ...
|
|
|
|
//
|
|
// KI ...
|
|
|
|
//
|
|
isKIRejectUp = false;
|
|
isKIRejectDown = false;
|
|
|
|
//
|
|
isKIBullish = false;
|
|
isKIBearish = false;
|
|
|
|
//
|
|
isKISwitchedToBullish = false;
|
|
isKISwitchedToBearish = false;
|
|
|
|
//
|
|
// TKI ...
|
|
|
|
//
|
|
isTKIRejectUp = false;
|
|
isTKIRejectDown = false;
|
|
|
|
//
|
|
isTKIBullish = false;
|
|
isTKIBearish = false;
|
|
|
|
//
|
|
isTKISwitchedToBullish = false;
|
|
isTKISwitchedToBearish = false;
|
|
|
|
//
|
|
// SAR ...
|
|
|
|
//
|
|
isSarBullish = false;
|
|
isSarBearish = false;
|
|
|
|
//
|
|
isSarSwitchedToBullish = false;
|
|
isSarSwitchedToBearish = false;
|
|
|
|
//
|
|
// PEAK ...
|
|
|
|
//
|
|
isPeakSameLast = false;
|
|
isPeakOverLast = false;
|
|
isPeakUnderLast = false;
|
|
|
|
//
|
|
// VALE ...
|
|
|
|
//
|
|
isValeSameLast = false;
|
|
isValeOverLast = false;
|
|
isValeUnderLast = false;
|
|
|
|
//
|
|
// TREND ...
|
|
|
|
//
|
|
isTrendRejectUp = false;
|
|
isTrendRejectDown = false;
|
|
|
|
//
|
|
isTrendBullish = false;
|
|
isTrendBearish = false;
|
|
|
|
//
|
|
isTrendSwitchedToBullish = false;
|
|
isTrendSwitchedToBearish = false;
|
|
|
|
//
|
|
// SUPPORT ...
|
|
|
|
//
|
|
isSupportSameLast = false;
|
|
isSupportOverLast = false;
|
|
isSupportUnderLast = false;
|
|
|
|
//
|
|
isLastSupportBreaked = false;
|
|
isLastSupportRejected = false;
|
|
|
|
//
|
|
// RESISTANCE ...
|
|
|
|
//
|
|
isResistanceSameLast = false;
|
|
isResistanceOverLast = false;
|
|
isResistanceUnderLast = false;
|
|
|
|
//
|
|
isLastResistanceBreaked = false;
|
|
isLastResistanceRejected = false;
|
|
|
|
//
|
|
// SWING Low ...
|
|
|
|
//
|
|
isSwingLowSameLast = false;
|
|
isSwingLowOverLast = false;
|
|
isSwingLowUnderLast = false;
|
|
|
|
//
|
|
isLastSwingLowBreaked = false;
|
|
isLastSwingLowRejected = false;
|
|
|
|
//
|
|
// SWING High ...
|
|
|
|
//
|
|
isSwingHighSameLast = false;
|
|
isSwingHighOverLast = false;
|
|
isSwingHighUnderLast = false;
|
|
|
|
//
|
|
isLastSwingHighBreaked = false;
|
|
isLastSwingHighRejected = false;
|
|
|
|
//
|
|
// COMPLEX Conditions ...
|
|
|
|
//
|
|
isPeakIsPivot = false;
|
|
isValeIsPivot = false;
|
|
|
|
//
|
|
isSwingLowSameAsVale = false;
|
|
isSwingHighSameAsPeak = false;
|
|
|
|
//
|
|
isSupportSameAsVale = false;
|
|
isResistanceSameAsPeak = false;
|
|
|
|
//
|
|
isSupportSameAsSwingLow = false;
|
|
isResistanceSameAsSwingHigh = false;
|
|
|
|
//
|
|
// XOSCS ...
|
|
|
|
//
|
|
// Buffers ...
|
|
|
|
//
|
|
Clean(acBuffer);
|
|
Clean(adBuffer);
|
|
Clean(atrBuffer);
|
|
Clean(cciBuffer);
|
|
Clean(rsiBuffer);
|
|
Clean(mfiBuffer);
|
|
Clean(rviBuffer);
|
|
Clean(adxBuffer);
|
|
Clean(adxpBuffer);
|
|
Clean(adxnBuffer);
|
|
Clean(macdBuffer);
|
|
Clean(momentumBuffer);
|
|
Clean(rviSignalBuffer);
|
|
Clean(macdSignalBuffer);
|
|
Clean(stochasticBuffer);
|
|
Clean(stochasticSignalBuffer);
|
|
|
|
//
|
|
ArraySetAsSeries(acBuffer, true);
|
|
ArraySetAsSeries(adBuffer, true);
|
|
ArraySetAsSeries(atrBuffer, true);
|
|
ArraySetAsSeries(cciBuffer, true);
|
|
ArraySetAsSeries(rsiBuffer, true);
|
|
ArraySetAsSeries(mfiBuffer, true);
|
|
ArraySetAsSeries(rviBuffer, true);
|
|
ArraySetAsSeries(adxBuffer, true);
|
|
ArraySetAsSeries(adxpBuffer, true);
|
|
ArraySetAsSeries(adxnBuffer, true);
|
|
ArraySetAsSeries(macdBuffer, true);
|
|
ArraySetAsSeries(momentumBuffer, true);
|
|
ArraySetAsSeries(rviSignalBuffer, true);
|
|
ArraySetAsSeries(macdSignalBuffer, true);
|
|
ArraySetAsSeries(stochasticBuffer, true);
|
|
ArraySetAsSeries(stochasticSignalBuffer, true);
|
|
|
|
//
|
|
// Conditions ...
|
|
|
|
//
|
|
// AC ...
|
|
|
|
//
|
|
isACBullish = false;
|
|
isACBearish = false;
|
|
isACSwitchedToBullish = false;
|
|
isACSwitchedToBearish = false;
|
|
isACOverMax = false;
|
|
isACUnderMin = false;
|
|
|
|
//
|
|
// AD ...
|
|
|
|
//
|
|
isADBiggerLast = false;
|
|
isADLesserLast = false;
|
|
isADOverMax = false;
|
|
isADUnderMin = false;
|
|
|
|
//
|
|
// ADX ...
|
|
|
|
//
|
|
isADXBiggerLast = false;
|
|
isADXLesserLast = false;
|
|
isADXOverThreshold = false;
|
|
isADXUnderThreshold = false;
|
|
isDXPBiggerThanDXN = false;
|
|
isDXNBiggerThanDXP = false;
|
|
isADXBullish = false;
|
|
isADXBearish = false;
|
|
isADXSwitchedToBullish = false;
|
|
isADXSwitchedToBearish = false;
|
|
|
|
//
|
|
// ATR ...
|
|
|
|
//
|
|
isATROverLast = false;
|
|
isATRUnderLast = false;
|
|
|
|
//
|
|
// CCI ...
|
|
|
|
//
|
|
isCCIBullish = false;
|
|
isCCIBearish = false;
|
|
isCCISwitchedToBullish = false;
|
|
isCCISwitchedToBearish = false;
|
|
isCCIOB = false;
|
|
isCCIOS = false;
|
|
isCCICrossedOverOB = false;
|
|
isCCICrossedOverOS = false;
|
|
isCCICrossedUnderOB = false;
|
|
isCCICrossedUnderOS = false;
|
|
|
|
//
|
|
// RSI ...
|
|
|
|
//
|
|
isRSIBullish = false;
|
|
isRSIBearish = false;
|
|
isRSISwitchedToBullish = false;
|
|
isRSISwitchedToBearish = false;
|
|
isRSIOB = false;
|
|
isRSIOS = false;
|
|
isRSICrossedOverOB = false;
|
|
isRSICrossedOverOS = false;
|
|
isRSICrossedUnderOB = false;
|
|
isRSICrossedUnderOS = false;
|
|
|
|
//
|
|
// MFI ...
|
|
|
|
//
|
|
isMFIBullish = false;
|
|
isMFIBearish = false;
|
|
isMFISwitchedToBullish = false;
|
|
isMFISwitchedToBearish = false;
|
|
isMFIOB = false;
|
|
isMFIOS = false;
|
|
isMFICrossedOverOB = false;
|
|
isMFICrossedOverOS = false;
|
|
isMFICrossedUnderOB = false;
|
|
isMFICrossedUnderOS = false;
|
|
|
|
//
|
|
// RVI ...
|
|
|
|
//
|
|
isRVIBullish = false;
|
|
isRVIBearish = false;
|
|
isRVISwitchedToBullish = false;
|
|
isRVISwitchedToBearish = false;
|
|
isRVIOverSignal = false;
|
|
isRVIUnderSignal = false;
|
|
isRVICrossedOverSignal = false;
|
|
isRVICrossedUnderSignal = false;
|
|
|
|
//
|
|
// MACD ...
|
|
|
|
//
|
|
isMACDBullish = false;
|
|
isMACDBearish = false;
|
|
isMACDSwitchedToBullish = false;
|
|
isMACDSwitchedToBearish = false;
|
|
isMACDOverSignal = false;
|
|
isMACDUnderSignal = false;
|
|
isMACDCrossedOverSignal = false;
|
|
isMACDCrossedUnderSignal = false;
|
|
|
|
//
|
|
// MOMENTUM ...
|
|
|
|
//
|
|
isMomentumBullish = false;
|
|
isMomentumBearish = false;
|
|
isMomentumSwitchedToBullish = false;
|
|
isMomentumSwitchedToBearish = false;
|
|
|
|
//
|
|
// STOCHASTIC ...
|
|
|
|
//
|
|
isStochasticBullish = false;
|
|
isStochasticBearish = false;
|
|
isStochasticSwitchedToBullish = false;
|
|
isStochasticSwitchedToBearish = false;
|
|
isStochasticOverSignal = false;
|
|
isStochasticUnderSignal = false;
|
|
isStochasticCrossedOverSignal = false;
|
|
isStochasticCrossedUnderSignal = false;
|
|
isStochasticOB = false;
|
|
isStochasticOS = false;
|
|
isStochasticCrossedOverOB = false;
|
|
isStochasticCrossedOverOS = false;
|
|
isStochasticCrossedUnderOB = false;
|
|
isStochasticCrossedUnderOS = false;
|
|
|
|
//
|
|
ZeroMemory(this);
|
|
}
|
|
|
|
/**
|
|
* Generate Conditions Scores ...
|
|
*
|
|
* @param bullishScore: Double, Directional Scores Reference ...
|
|
* @param bearishScore: Double, Directional Scores Reference ...
|
|
*/
|
|
void GenerateScore(
|
|
double &bullishScore,
|
|
double &bearishScore //
|
|
)
|
|
{
|
|
//
|
|
bullishScore = 0;
|
|
bearishScore = 0;
|
|
|
|
//
|
|
double score = 1;
|
|
double minScore = 0.5;
|
|
double highScore = 1.5;
|
|
|
|
//
|
|
// XCA ...
|
|
|
|
//
|
|
// KI ...
|
|
|
|
//
|
|
if (isKIBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isKIRejectUp)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isKISwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isKIBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isKIRejectDown)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isKISwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// TKI ...
|
|
|
|
//
|
|
if (isTKIBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isTKIRejectUp)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isTKISwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isTKIBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isTKIRejectDown)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isTKISwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// SAR ...
|
|
|
|
//
|
|
if (isSarBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isSarSwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isSarBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isSarSwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// TREND ...
|
|
|
|
//
|
|
if (isTrendBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isTrendRejectUp)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isTrendSwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isTrendBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isTrendRejectDown)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isTrendSwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// SUPPORT ...
|
|
|
|
//
|
|
if (isSupportSameLast)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isSupportOverLast)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isLastSupportRejected)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isSupportUnderLast)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isLastSupportBreaked)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// RESISTANCE ...
|
|
|
|
//
|
|
if (isResistanceOverLast)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isLastResistanceBreaked)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isResistanceSameLast)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isResistanceUnderLast)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isLastResistanceRejected)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// SWING Low ...
|
|
|
|
//
|
|
if (isSwingLowSameLast)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isSwingLowOverLast)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isLastSwingLowRejected)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isSwingLowUnderLast)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isLastSwingLowBreaked)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// SWING High ...
|
|
|
|
//
|
|
if (isSwingHighOverLast)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isLastSwingHighBreaked)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isSwingHighSameLast)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isSwingHighUnderLast)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isLastSwingHighRejected)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// COMPLEX Conditions ...
|
|
|
|
//
|
|
if (isValeIsPivot)
|
|
{
|
|
bullishScore += score;
|
|
}
|
|
if (isSupportSameAsVale)
|
|
{
|
|
bullishScore += score;
|
|
}
|
|
if (isSwingLowSameAsVale)
|
|
{
|
|
bullishScore += score;
|
|
}
|
|
if (isSupportSameAsSwingLow)
|
|
{
|
|
bullishScore += score;
|
|
}
|
|
|
|
//
|
|
if (isPeakIsPivot)
|
|
{
|
|
bearishScore += score;
|
|
}
|
|
if (isSwingHighSameAsPeak)
|
|
{
|
|
bearishScore += score;
|
|
}
|
|
if (isResistanceSameAsPeak)
|
|
{
|
|
bearishScore += score;
|
|
}
|
|
if (isResistanceSameAsSwingHigh)
|
|
{
|
|
bearishScore += score;
|
|
}
|
|
|
|
//
|
|
// XOCS ...
|
|
|
|
//
|
|
// AC ...
|
|
|
|
//
|
|
if (isACBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isACOverMax)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isACSwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isACBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isACUnderMin)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isACSwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// AD ...
|
|
|
|
//
|
|
if (isADOverMax)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isADBiggerLast)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isADUnderMin)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isADLesserLast)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// ADX ...
|
|
|
|
//
|
|
if (isADXBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isADXBiggerLast)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isADXOverThreshold)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isDXPBiggerThanDXN)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isADXSwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isADXBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isADXLesserLast)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isDXNBiggerThanDXP)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isADXUnderThreshold)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isADXSwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// ATR ...
|
|
|
|
//
|
|
if (isATROverLast)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isATRUnderLast)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// CCI ...
|
|
|
|
//
|
|
if (isCCIOS)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isCCIBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isCCICrossedOverOS)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isCCICrossedOverOB)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isCCISwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isCCIOB)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isCCIBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isCCICrossedUnderOS)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isCCICrossedUnderOB)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isCCISwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// RSI ...
|
|
|
|
//
|
|
if (isRSIOS)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isRSIBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isRSICrossedOverOB)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isRSICrossedOverOS)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isRSISwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isRSIOB)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isRSIBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isRSICrossedUnderOB)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isRSICrossedUnderOS)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isRSISwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// MFI ...
|
|
|
|
//
|
|
if (isMFIOS)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isMFIBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isMFICrossedOverOB)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isMFICrossedOverOS)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isMFISwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isMFIOB)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isMFIBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isMFICrossedUnderOB)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isMFICrossedUnderOS)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isMFISwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// RVI ...
|
|
|
|
//
|
|
if (isRVIBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isRVIOverSignal)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isRVISwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isRVICrossedOverSignal)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isRVIBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isRVIUnderSignal)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isRVISwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isRVICrossedUnderSignal)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// MACD ...
|
|
|
|
//
|
|
if (isMACDBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isMACDOverSignal)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isMACDSwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isMACDCrossedOverSignal)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isMACDBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isMACDUnderSignal)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isMACDSwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isMACDCrossedUnderSignal)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// MOMENTUM ...
|
|
|
|
//
|
|
if (isMomentumBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isMomentumSwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isMomentumBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isMomentumSwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// STOCHASTIC ...
|
|
|
|
//
|
|
if (isStochasticOS)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isStochasticOverSignal)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isStochasticBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isStochasticCrossedOverSignal)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isStochasticCrossedOverOB)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isStochasticCrossedOverOS)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isStochasticSwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isStochasticOB)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isStochasticUnderSignal)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isStochasticBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isStochasticCrossedUnderSignal)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isStochasticCrossedUnderOB)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isStochasticCrossedUnderOS)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isStochasticSwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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" //
|
|
)
|
|
{
|
|
//
|
|
string result = NULL;
|
|
|
|
//
|
|
double bullishScore = 0;
|
|
double bearishScore = 0;
|
|
GenerateScore(
|
|
bullishScore,
|
|
bearishScore //
|
|
);
|
|
|
|
//
|
|
string scoresStr =
|
|
//
|
|
"Scores: " + separator +
|
|
"---------------" + separator +
|
|
"Bullish: " + ToString(bullishScore) + separator +
|
|
"Bearish: " + ToString(bearishScore) + separator +
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
string commonStr = GenerateSpecifiedCommonSummary(
|
|
this,
|
|
separator,
|
|
includeScores //
|
|
);
|
|
|
|
//
|
|
string conditionsStr =
|
|
//
|
|
//
|
|
"-----------------------" + separator +
|
|
"XCA: " + separator +
|
|
"-----------------------" + separator +
|
|
ToString("isKIRejectUp", isKIRejectUp, ignoreFalseConditions, separator) +
|
|
ToString("isKIRejectDown", isKIRejectDown, ignoreFalseConditions, separator) +
|
|
ToString("isKIBullish", isKIBullish, ignoreFalseConditions, separator) +
|
|
ToString("isKIBearish", isKIBearish, ignoreFalseConditions, separator) +
|
|
ToString("isKISwitchedToBullish", isKISwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isKISwitchedToBearish", isKISwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isTKIRejectUp", isTKIRejectUp, ignoreFalseConditions, separator) +
|
|
ToString("isTKIRejectDown", isTKIRejectDown, ignoreFalseConditions, separator) +
|
|
ToString("isTKIBullish", isTKIBullish, ignoreFalseConditions, separator) +
|
|
ToString("isTKIBearish", isTKIBearish, ignoreFalseConditions, separator) +
|
|
ToString("isTKISwitchedToBullish", isTKISwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isTKISwitchedToBearish", isTKISwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isSarBullish", isSarBullish, ignoreFalseConditions, separator) +
|
|
ToString("isSarBearish", isSarBearish, ignoreFalseConditions, separator) +
|
|
ToString("isSarSwitchedToBullish", isSarSwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isSarSwitchedToBearish", isSarSwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isPeakSameLast", isPeakSameLast, ignoreFalseConditions, separator) +
|
|
ToString("isPeakOverLast", isPeakOverLast, ignoreFalseConditions, separator) +
|
|
ToString("isPeakUnderLast", isPeakUnderLast, ignoreFalseConditions, separator) +
|
|
ToString("isValeSameLast", isValeSameLast, ignoreFalseConditions, separator) +
|
|
ToString("isValeOverLast", isValeOverLast, ignoreFalseConditions, separator) +
|
|
ToString("isValeUnderLast", isValeUnderLast, ignoreFalseConditions, separator) +
|
|
ToString("isTrendRejectUp", isTrendRejectUp, ignoreFalseConditions, separator) +
|
|
ToString("isTrendRejectDown", isTrendRejectDown, ignoreFalseConditions, separator) +
|
|
ToString("isTrendBullish", isTrendBullish, ignoreFalseConditions, separator) +
|
|
ToString("isTrendBearish", isTrendBearish, ignoreFalseConditions, separator) +
|
|
ToString("isTrendSwitchedToBullish", isTrendSwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isTrendSwitchedToBearish", isTrendSwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isSupportSameLast", isSupportSameLast, ignoreFalseConditions, separator) +
|
|
ToString("isSupportOverLast", isSupportOverLast, ignoreFalseConditions, separator) +
|
|
ToString("isSupportUnderLast", isSupportUnderLast, ignoreFalseConditions, separator) +
|
|
ToString("isLastSupportBreaked", isLastSupportBreaked, ignoreFalseConditions, separator) +
|
|
ToString("isLastSupportRejected", isLastSupportRejected, ignoreFalseConditions, separator) +
|
|
ToString("isResistanceSameLast", isResistanceSameLast, ignoreFalseConditions, separator) +
|
|
ToString("isResistanceOverLast", isResistanceOverLast, ignoreFalseConditions, separator) +
|
|
ToString("isResistanceUnderLast", isResistanceUnderLast, ignoreFalseConditions, separator) +
|
|
ToString("isLastResistanceBreaked", isLastResistanceBreaked, ignoreFalseConditions, separator) +
|
|
ToString("isLastResistanceRejected", isLastResistanceRejected, ignoreFalseConditions, separator) +
|
|
ToString("isSwingLowSameLast", isSwingLowSameLast, ignoreFalseConditions, separator) +
|
|
ToString("isSwingLowOverLast", isSwingLowOverLast, ignoreFalseConditions, separator) +
|
|
ToString("isSwingLowUnderLast", isSwingLowUnderLast, ignoreFalseConditions, separator) +
|
|
ToString("isLastSwingLowBreaked", isLastSwingLowBreaked, ignoreFalseConditions, separator) +
|
|
ToString("isLastSwingLowRejected", isLastSwingLowRejected, ignoreFalseConditions, separator) +
|
|
ToString("isSwingHighSameLast", isSwingHighSameLast, ignoreFalseConditions, separator) +
|
|
ToString("isSwingHighOverLast", isSwingHighOverLast, ignoreFalseConditions, separator) +
|
|
ToString("isSwingHighUnderLast", isSwingHighUnderLast, ignoreFalseConditions, separator) +
|
|
ToString("isLastSwingHighBreaked", isLastSwingHighBreaked, ignoreFalseConditions, separator) +
|
|
ToString("isLastSwingHighRejected", isLastSwingHighRejected, ignoreFalseConditions, separator) +
|
|
ToString("isPeakIsPivot", isPeakIsPivot, ignoreFalseConditions, separator) +
|
|
ToString("isValeIsPivot", isValeIsPivot, ignoreFalseConditions, separator) +
|
|
ToString("isSwingLowSameAsVale", isSwingLowSameAsVale, ignoreFalseConditions, separator) +
|
|
ToString("isSwingHighSameAsPeak", isSwingHighSameAsPeak, ignoreFalseConditions, separator) +
|
|
ToString("isSupportSameAsVale", isSupportSameAsVale, ignoreFalseConditions, separator) +
|
|
ToString("isResistanceSameAsPeak", isResistanceSameAsPeak, ignoreFalseConditions, separator) +
|
|
ToString("isSupportSameAsSwingLow", isSupportSameAsSwingLow, ignoreFalseConditions, separator) +
|
|
ToString("isResistanceSameAsSwingHigh", isResistanceSameAsSwingHigh, ignoreFalseConditions, separator) +
|
|
"-----------------------" + separator +
|
|
"XOCS: " + separator +
|
|
"-----------------------" + separator +
|
|
ToString("isACBullish", isACBullish, ignoreFalseConditions, separator) +
|
|
ToString("isACBearish", isACBearish, ignoreFalseConditions, separator) +
|
|
ToString("isACSwitchedToBullish", isACSwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isACSwitchedToBearish", isACSwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isACOverMax", isACOverMax, ignoreFalseConditions, separator) +
|
|
ToString("isACUnderMin", isACUnderMin, ignoreFalseConditions, separator) +
|
|
ToString("isADBiggerLast", isADBiggerLast, ignoreFalseConditions, separator) +
|
|
ToString("isADLesserLast", isADLesserLast, ignoreFalseConditions, separator) +
|
|
ToString("isADOverMax", isADOverMax, ignoreFalseConditions, separator) +
|
|
ToString("isADUnderMin", isADUnderMin, ignoreFalseConditions, separator) +
|
|
ToString("isADXBiggerLast", isADXBiggerLast, ignoreFalseConditions, separator) +
|
|
ToString("isADXLesserLast", isADXLesserLast, ignoreFalseConditions, separator) +
|
|
ToString("isADXOverThreshold", isADXOverThreshold, ignoreFalseConditions, separator) +
|
|
ToString("isADXUnderThreshold", isADXUnderThreshold, ignoreFalseConditions, separator) +
|
|
ToString("isDXPBiggerThanDXN", isDXPBiggerThanDXN, ignoreFalseConditions, separator) +
|
|
ToString("isDXNBiggerThanDXP", isDXNBiggerThanDXP, ignoreFalseConditions, separator) +
|
|
ToString("isADXBullish", isADXBullish, ignoreFalseConditions, separator) +
|
|
ToString("isADXBearish", isADXBearish, ignoreFalseConditions, separator) +
|
|
ToString("isADXSwitchedToBullish", isADXSwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isADXSwitchedToBearish", isADXSwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isATROverLast", isATROverLast, ignoreFalseConditions, separator) +
|
|
ToString("isATRUnderLast", isATRUnderLast, ignoreFalseConditions, separator) +
|
|
ToString("isCCIBullish", isCCIBullish, ignoreFalseConditions, separator) +
|
|
ToString("isCCIBearish", isCCIBearish, ignoreFalseConditions, separator) +
|
|
ToString("isCCISwitchedToBullish", isCCISwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isCCISwitchedToBearish", isCCISwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isCCIOB", isCCIOB, ignoreFalseConditions, separator) +
|
|
ToString("isCCIOS", isCCIOS, ignoreFalseConditions, separator) +
|
|
ToString("isCCICrossedOverOB", isCCICrossedOverOB, ignoreFalseConditions, separator) +
|
|
ToString("isCCICrossedOverOS", isCCICrossedOverOS, ignoreFalseConditions, separator) +
|
|
ToString("isCCICrossedUnderOB", isCCICrossedUnderOB, ignoreFalseConditions, separator) +
|
|
ToString("isCCICrossedUnderOS", isCCICrossedUnderOS, ignoreFalseConditions, separator) +
|
|
ToString("isRSIBullish", isRSIBullish, ignoreFalseConditions, separator) +
|
|
ToString("isRSIBearish", isRSIBearish, ignoreFalseConditions, separator) +
|
|
ToString("isRSISwitchedToBullish", isRSISwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isRSISwitchedToBearish", isRSISwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isRSIOB", isRSIOB, ignoreFalseConditions, separator) +
|
|
ToString("isRSIOS", isRSIOS, ignoreFalseConditions, separator) +
|
|
ToString("isRSICrossedOverOB", isRSICrossedOverOB, ignoreFalseConditions, separator) +
|
|
ToString("isRSICrossedOverOS", isRSICrossedOverOS, ignoreFalseConditions, separator) +
|
|
ToString("isRSICrossedUnderOB", isRSICrossedUnderOB, ignoreFalseConditions, separator) +
|
|
ToString("isRSICrossedUnderOS", isRSICrossedUnderOS, ignoreFalseConditions, separator) +
|
|
ToString("isMFIBullish", isMFIBullish, ignoreFalseConditions, separator) +
|
|
ToString("isMFIBearish", isMFIBearish, ignoreFalseConditions, separator) +
|
|
ToString("isMFISwitchedToBullish", isMFISwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isMFISwitchedToBearish", isMFISwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isMFIOB", isMFIOB, ignoreFalseConditions, separator) +
|
|
ToString("isMFIOS", isMFIOS, ignoreFalseConditions, separator) +
|
|
ToString("isMFICrossedOverOB", isMFICrossedOverOB, ignoreFalseConditions, separator) +
|
|
ToString("isMFICrossedOverOS", isMFICrossedOverOS, ignoreFalseConditions, separator) +
|
|
ToString("isMFICrossedUnderOB", isMFICrossedUnderOB, ignoreFalseConditions, separator) +
|
|
ToString("isMFICrossedUnderOS", isMFICrossedUnderOS, ignoreFalseConditions, separator) +
|
|
ToString("isRVIBullish", isRVIBullish, ignoreFalseConditions, separator) +
|
|
ToString("isRVIBearish", isRVIBearish, ignoreFalseConditions, separator) +
|
|
ToString("isRVISwitchedToBullish", isRVISwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isRVISwitchedToBearish", isRVISwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isRVIOverSignal", isRVIOverSignal, ignoreFalseConditions, separator) +
|
|
ToString("isRVIUnderSignal", isRVIUnderSignal, ignoreFalseConditions, separator) +
|
|
ToString("isRVICrossedOverSignal", isRVICrossedOverSignal, ignoreFalseConditions, separator) +
|
|
ToString("isRVICrossedUnderSignal", isRVICrossedUnderSignal, ignoreFalseConditions, separator) +
|
|
ToString("isMACDBullish", isMACDBullish, ignoreFalseConditions, separator) +
|
|
ToString("isMACDBearish", isMACDBearish, ignoreFalseConditions, separator) +
|
|
ToString("isMACDSwitchedToBullish", isMACDSwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isMACDSwitchedToBearish", isMACDSwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isMACDOverSignal", isMACDOverSignal, ignoreFalseConditions, separator) +
|
|
ToString("isMACDUnderSignal", isMACDUnderSignal, ignoreFalseConditions, separator) +
|
|
ToString("isMACDCrossedOverSignal", isMACDCrossedOverSignal, ignoreFalseConditions, separator) +
|
|
ToString("isMACDCrossedUnderSignal", isMACDCrossedUnderSignal, ignoreFalseConditions, separator) +
|
|
ToString("isMomentumBullish", isMomentumBullish, ignoreFalseConditions, separator) +
|
|
ToString("isMomentumBearish", isMomentumBearish, ignoreFalseConditions, separator) +
|
|
ToString("isMomentumSwitchedToBullish", isMomentumSwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isMomentumSwitchedToBearish", isMomentumSwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isStochasticBullish", isStochasticBullish, ignoreFalseConditions, separator) +
|
|
ToString("isStochasticBearish", isStochasticBearish, ignoreFalseConditions, separator) +
|
|
ToString("isStochasticSwitchedToBullish", isStochasticSwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isStochasticSwitchedToBearish", isStochasticSwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isStochasticOverSignal", isStochasticOverSignal, ignoreFalseConditions, separator) +
|
|
ToString("isStochasticUnderSignal", isStochasticUnderSignal, ignoreFalseConditions, separator) +
|
|
ToString("isStochasticCrossedOverSignal", isStochasticCrossedOverSignal, ignoreFalseConditions, separator) +
|
|
ToString("isStochasticCrossedUnderSignal", isStochasticCrossedUnderSignal, ignoreFalseConditions, separator) +
|
|
ToString("isStochasticOB", isStochasticOB, ignoreFalseConditions, separator) +
|
|
ToString("isStochasticOS", isStochasticOS, ignoreFalseConditions, separator) +
|
|
ToString("isStochasticCrossedOverOB", isStochasticCrossedOverOB, ignoreFalseConditions, separator) +
|
|
ToString("isStochasticCrossedOverOS", isStochasticCrossedOverOS, ignoreFalseConditions, separator) +
|
|
ToString("isStochasticCrossedUnderOB", isStochasticCrossedUnderOB, ignoreFalseConditions, separator) +
|
|
ToString("isStochasticCrossedUnderOS", isStochasticCrossedUnderOS, ignoreFalseConditions, separator) +
|
|
//
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
result =
|
|
//
|
|
"[" + GetTag() + "]" + separator +
|
|
(onlyConditions
|
|
? ""
|
|
: commonStr) +
|
|
(!includeScores
|
|
? ""
|
|
: scoresStr) +
|
|
" " + separator +
|
|
(onlyCommons
|
|
? ""
|
|
: conditionsStr) +
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Retrieve nique Tag Identifier ...
|
|
*
|
|
* @return ( string )
|
|
*/
|
|
string GetTag()
|
|
{
|
|
return GetTypeName(this);
|
|
}
|
|
};
|
|
|
|
//
|
|
// Helper Class Implementation ...
|
|
class XCXCAEAHelper : XCBase
|
|
{
|
|
//
|
|
// Public ...
|
|
public:
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
XCPOIDrawer *poiDrawer;
|
|
XCPOIDetector *poiDetector;
|
|
|
|
//
|
|
XCBarAnalyser *barAnalyser;
|
|
|
|
//
|
|
XCX121XCCHelper *ccHelper;
|
|
XCX121XCTHelper *ctHelper;
|
|
XCX121XCAHelper *caHelper;
|
|
XCX121XOCSHelper *ocsHelper;
|
|
|
|
//
|
|
// Constructor ...
|
|
XCXCAEAHelper()
|
|
{
|
|
//
|
|
barAnalyser = new XCBarAnalyser();
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
~XCXCAEAHelper()
|
|
{
|
|
//
|
|
mInputs.Clean();
|
|
|
|
//
|
|
ZeroMemory(ccHelper);
|
|
ZeroMemory(ctHelper);
|
|
ZeroMemory(caHelper);
|
|
ZeroMemory(ocsHelper);
|
|
|
|
//
|
|
ZeroMemory(poiDrawer);
|
|
ZeroMemory(poiDetector);
|
|
ZeroMemory(barAnalyser);
|
|
|
|
//
|
|
IndicatorRelease(acHandler);
|
|
IndicatorRelease(adHandler);
|
|
IndicatorRelease(adxHandler);
|
|
IndicatorRelease(atrHandler);
|
|
IndicatorRelease(cciHandler);
|
|
IndicatorRelease(rsiHandler);
|
|
IndicatorRelease(mfiHandler);
|
|
IndicatorRelease(rviHandler);
|
|
IndicatorRelease(macdHandler);
|
|
IndicatorRelease(momentumHandler);
|
|
IndicatorRelease(stochasticHandler);
|
|
}
|
|
|
|
//
|
|
string GetSymbol()
|
|
{
|
|
return mSymbol;
|
|
}
|
|
|
|
//
|
|
ENUM_TIMEFRAMES GetPeriod()
|
|
{
|
|
return mPeriod;
|
|
}
|
|
|
|
//
|
|
// Tools ...
|
|
|
|
/**
|
|
* Initialize Indicator Helper ...
|
|
*
|
|
* @param symbol: String, Symbol ...
|
|
* @param period: ENUM_TIMEFRAMES member, Period ...
|
|
* @param inputs: XCAEAInputs instance, Indicator Inputs ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Init(
|
|
string symbol, // Trading Symbol
|
|
ENUM_TIMEFRAMES period, // Trading Period
|
|
XCAEAInputs &inputs // Inputs
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
IsValid(symbol) &&
|
|
IsValid(period) &&
|
|
inputs.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
mSymbol = symbol;
|
|
mPeriod = period;
|
|
|
|
//
|
|
poiDetector = new XCPOIDetector(
|
|
symbol,
|
|
period //
|
|
);
|
|
poiDetector.Init();
|
|
|
|
//
|
|
poiDrawer = new XCPOIDrawer();
|
|
|
|
//
|
|
// Setting Inputs ...
|
|
|
|
//
|
|
mInputs = inputs;
|
|
|
|
//
|
|
// Initial Helpers ...
|
|
|
|
//
|
|
// XCT ...
|
|
ctHelper = new XCX121XCTHelper();
|
|
result =
|
|
result &&
|
|
ctHelper.Init(
|
|
symbol,
|
|
period,
|
|
mInputs.ctInputs //
|
|
);
|
|
|
|
//
|
|
// XCC ...
|
|
ccHelper = new XCX121XCCHelper();
|
|
result =
|
|
result &&
|
|
ccHelper.Init(
|
|
symbol,
|
|
period,
|
|
mInputs.ccInputs //
|
|
);
|
|
|
|
//
|
|
// XCA ...
|
|
caHelper = new XCX121XCAHelper();
|
|
result =
|
|
result &&
|
|
caHelper.Init(
|
|
symbol,
|
|
period,
|
|
mInputs.caInputs //
|
|
);
|
|
|
|
//
|
|
// XOSC ...
|
|
ocsHelper = new XCX121XOCSHelper();
|
|
result =
|
|
result &&
|
|
ocsHelper.Init(
|
|
symbol,
|
|
period,
|
|
mInputs.oscsInputs //
|
|
);
|
|
|
|
//
|
|
if (!result)
|
|
{
|
|
//
|
|
ZeroMemory(ccHelper);
|
|
ZeroMemory(ctHelper);
|
|
ZeroMemory(caHelper);
|
|
ZeroMemory(ocsHelper);
|
|
|
|
//
|
|
ZeroMemory(poiDrawer);
|
|
ZeroMemory(poiDetector);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// OSCILLATORS Viewers ...
|
|
|
|
//
|
|
// AC ...
|
|
if (mInputs.showAC)
|
|
{
|
|
//
|
|
acHandler = iAC(
|
|
symbol,
|
|
period //
|
|
);
|
|
|
|
//
|
|
result =
|
|
result &&
|
|
acHandler != INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// AD ...
|
|
if (mInputs.showAD)
|
|
{
|
|
//
|
|
adHandler = iAD(
|
|
symbol,
|
|
period,
|
|
mInputs.oscsInputs.adAppliedTo //
|
|
);
|
|
|
|
//
|
|
result =
|
|
result &&
|
|
adHandler != INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// ADX ...
|
|
if (mInputs.showADX)
|
|
{
|
|
//
|
|
adxHandler = iADX(
|
|
symbol,
|
|
period,
|
|
mInputs.oscsInputs.adxLength //
|
|
);
|
|
|
|
//
|
|
result =
|
|
result &&
|
|
adxHandler != INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// ATR ...
|
|
if (mInputs.showATR)
|
|
{
|
|
//
|
|
atrHandler = iATR(
|
|
symbol,
|
|
period,
|
|
mInputs.oscsInputs.atrLength //
|
|
);
|
|
|
|
//
|
|
result =
|
|
result &&
|
|
atrHandler != INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// CCI ...
|
|
if (mInputs.showCCI)
|
|
{
|
|
//
|
|
cciHandler = iCCI(
|
|
symbol,
|
|
period,
|
|
mInputs.oscsInputs.cciLength,
|
|
mInputs.oscsInputs.cciAppliedTo //
|
|
);
|
|
|
|
//
|
|
result =
|
|
result &&
|
|
cciHandler != INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// RSI ...
|
|
if (mInputs.showRSI)
|
|
{
|
|
//
|
|
rsiHandler = iRSI(
|
|
symbol,
|
|
period,
|
|
mInputs.oscsInputs.rsiLength,
|
|
mInputs.oscsInputs.rsiAppliedTo //
|
|
);
|
|
|
|
//
|
|
result =
|
|
result &&
|
|
rsiHandler != INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// MFI ...
|
|
if (mInputs.showMFI)
|
|
{
|
|
//
|
|
mfiHandler = iMFI(
|
|
symbol,
|
|
period,
|
|
mInputs.oscsInputs.mfiLength,
|
|
mInputs.oscsInputs.mfiAppliedTo //
|
|
);
|
|
|
|
//
|
|
result =
|
|
result &&
|
|
mfiHandler != INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// RVI ...
|
|
if (mInputs.showRVI)
|
|
{
|
|
//
|
|
rviHandler = iRVI(
|
|
symbol,
|
|
period,
|
|
mInputs.oscsInputs.rviLength //
|
|
);
|
|
|
|
//
|
|
result =
|
|
result &&
|
|
rviHandler != INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// MACD ...
|
|
if (mInputs.showMACD)
|
|
{
|
|
//
|
|
macdHandler = iMACD(
|
|
symbol,
|
|
period,
|
|
mInputs.oscsInputs.macdFastLength,
|
|
mInputs.oscsInputs.macdSlowLength,
|
|
mInputs.oscsInputs.macdSignalLength,
|
|
mInputs.oscsInputs.macdAppliedTo //
|
|
);
|
|
|
|
//
|
|
result =
|
|
result &&
|
|
macdHandler != INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// Momentum ...
|
|
if (mInputs.showMomentum)
|
|
{
|
|
//
|
|
momentumHandler = iMomentum(
|
|
symbol,
|
|
period,
|
|
mInputs.oscsInputs.momentumLength,
|
|
mInputs.oscsInputs.momentumAppliedTo //
|
|
);
|
|
|
|
//
|
|
result =
|
|
result &&
|
|
momentumHandler != INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// Stochastic ...
|
|
if (mInputs.showStochastic)
|
|
{
|
|
//
|
|
stochasticHandler = iStochastic(
|
|
symbol,
|
|
period,
|
|
mInputs.oscsInputs.stochasticKLength,
|
|
mInputs.oscsInputs.stochasticDLength,
|
|
mInputs.oscsInputs.stochasticSmoothingLength,
|
|
mInputs.oscsInputs.stochasticSmoothingMethod,
|
|
mInputs.oscsInputs.stochasticAppliedTo //
|
|
);
|
|
|
|
//
|
|
result =
|
|
result &&
|
|
stochasticHandler != INVALID_HANDLE;
|
|
}
|
|
|
|
//
|
|
// If Result is False, Cleanup Resources ...
|
|
if (!result)
|
|
{
|
|
//
|
|
mInputs.Clean();
|
|
|
|
//
|
|
ZeroMemory(ccHelper);
|
|
ZeroMemory(ctHelper);
|
|
ZeroMemory(caHelper);
|
|
ZeroMemory(ocsHelper);
|
|
|
|
//
|
|
IndicatorRelease(acHandler);
|
|
IndicatorRelease(adHandler);
|
|
IndicatorRelease(adxHandler);
|
|
IndicatorRelease(atrHandler);
|
|
IndicatorRelease(cciHandler);
|
|
IndicatorRelease(rsiHandler);
|
|
IndicatorRelease(mfiHandler);
|
|
IndicatorRelease(rviHandler);
|
|
IndicatorRelease(macdHandler);
|
|
IndicatorRelease(momentumHandler);
|
|
IndicatorRelease(stochasticHandler);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Conditions Readers ...
|
|
|
|
/**
|
|
* Retrieve Conditions ...
|
|
*
|
|
* @param conditions: Argument 1
|
|
* @param barIndex: int, Specified Bar Index ...
|
|
* @param loopback: int, Loopback looking for others ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool GetCAConditions(
|
|
X121XCAConditions &conditions, //
|
|
int barIndex = 0, //
|
|
int loopback = 5 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = caHelper.GetConditions(
|
|
conditions,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Retrieve Conditions ...
|
|
*
|
|
* @param conditions: Argument 1
|
|
* @param barIndex: int, Specified Bar Index ...
|
|
* @param loopback: int, Loopback looking for others ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool GetOSCSConditions(
|
|
X121XOCSConditions &conditions, //
|
|
int barIndex = 0, //
|
|
int loopback = 5 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = ocsHelper.GetConditions(
|
|
conditions,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Others ...
|
|
|
|
//
|
|
void Free()
|
|
{
|
|
//
|
|
caHelper.Free();
|
|
ocsHelper.Free();
|
|
}
|
|
|
|
//
|
|
bool GetConditions(
|
|
XCAEAConditions &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();
|
|
|
|
//
|
|
int zIndex = barIndex;
|
|
int cIndex = zIndex + 1;
|
|
int pIndex = cIndex + 1;
|
|
int ppIndex = pIndex + 1;
|
|
|
|
//
|
|
XOHCL zBar;
|
|
XOHCL cBar;
|
|
XOHCL pBar;
|
|
XOHCL fromBar;
|
|
|
|
//
|
|
X121XCAConditions xcaConditions;
|
|
X121XOCSConditions xocsConditions;
|
|
|
|
//
|
|
result = zBar.Init(
|
|
mSymbol,
|
|
mPeriod,
|
|
zIndex //
|
|
);
|
|
result =
|
|
result &&
|
|
zBar.GetPreviousBar(cBar);
|
|
result =
|
|
result &&
|
|
cBar.GetPreviousBar(pBar);
|
|
result =
|
|
result &&
|
|
fromBar.Init(
|
|
zBar.symbol,
|
|
zBar.period,
|
|
zIndex + loopback);
|
|
|
|
//
|
|
// Conditions Retriever ...
|
|
|
|
//
|
|
// XCA ...
|
|
result =
|
|
result &&
|
|
GetCAConditions(
|
|
xcaConditions,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
|
|
//
|
|
// XOSCS ...
|
|
result =
|
|
result &&
|
|
GetOSCSConditions(
|
|
xocsConditions,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
|
|
//
|
|
// Check Result ...
|
|
if (!result)
|
|
{
|
|
//
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
fromBar.Clean();
|
|
|
|
//
|
|
xcaConditions.Clean();
|
|
xocsConditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
conditions.to = zBar.time;
|
|
conditions.from = fromBar.time;
|
|
|
|
//
|
|
// Fill X121 Conditions Reference by Using
|
|
// Retrieved Conditions ...
|
|
|
|
//
|
|
int cIDX = 1;
|
|
int pIDX = cIDX + 1;
|
|
|
|
//
|
|
// XCA ...
|
|
|
|
//
|
|
// Buffers ...
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.kiBuffer,
|
|
conditions.kiBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.tkiBuffer,
|
|
conditions.tkiBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.sHHBuffer,
|
|
conditions.sHHBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.sLLBuffer,
|
|
conditions.sLLBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.mHHBuffer,
|
|
conditions.mHHBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.mLLBuffer,
|
|
conditions.mLLBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.lHHBuffer,
|
|
conditions.lHHBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.lLLBuffer,
|
|
conditions.lLLBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.hHHBuffer,
|
|
conditions.hHHBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.hLLBuffer,
|
|
conditions.hLLBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.sarBuffer,
|
|
conditions.sarBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.peakBuffer,
|
|
conditions.peakBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.valeBuffer,
|
|
conditions.valeBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.trendBuffer,
|
|
conditions.trendBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.kiStateBuffer,
|
|
conditions.kiStateBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.tkiStateBuffer,
|
|
conditions.tkiStateBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.supportBuffer,
|
|
conditions.supportBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.swingLowBuffer,
|
|
conditions.swingLowBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.swingHighBuffer,
|
|
conditions.swingHighBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.resistanceBuffer,
|
|
conditions.resistanceBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.peakGoldenBuffer,
|
|
conditions.peakGoldenBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.valeGoldenBuffer,
|
|
conditions.valeGoldenBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.fiboLevel1Buffer,
|
|
conditions.fiboLevel1Buffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.fiboLevel2Buffer,
|
|
conditions.fiboLevel2Buffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.fiboLevel3Buffer,
|
|
conditions.fiboLevel3Buffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.trendStateBuffer,
|
|
conditions.trendStateBuffer //
|
|
);
|
|
|
|
//
|
|
// Conditions ...
|
|
|
|
//
|
|
conditions.isKIBullish = xcaConditions.isKIBullish;
|
|
conditions.isKIBearish = xcaConditions.isKIBearish;
|
|
conditions.isKIRejectUp = xcaConditions.isKIRejectUp;
|
|
conditions.isTKIBullish = xcaConditions.isTKIBullish;
|
|
conditions.isTKIBearish = xcaConditions.isTKIBearish;
|
|
conditions.isSarBullish = xcaConditions.isSarBullish;
|
|
conditions.isSarBearish = xcaConditions.isSarBearish;
|
|
conditions.isTKIRejectUp = xcaConditions.isTKIRejectUp;
|
|
conditions.isPeakIsPivot = xcaConditions.isPeakIsPivot;
|
|
conditions.isValeIsPivot = xcaConditions.isValeIsPivot;
|
|
conditions.isKIRejectDown = xcaConditions.isKIRejectDown;
|
|
conditions.isPeakSameLast = xcaConditions.isPeakSameLast;
|
|
conditions.isPeakOverLast = xcaConditions.isPeakOverLast;
|
|
conditions.isValeSameLast = xcaConditions.isValeSameLast;
|
|
conditions.isValeOverLast = xcaConditions.isValeOverLast;
|
|
conditions.isTrendBullish = xcaConditions.isTrendBullish;
|
|
conditions.isTrendBearish = xcaConditions.isTrendBearish;
|
|
conditions.isTKIRejectDown = xcaConditions.isTKIRejectDown;
|
|
conditions.isPeakUnderLast = xcaConditions.isPeakUnderLast;
|
|
conditions.isValeUnderLast = xcaConditions.isValeUnderLast;
|
|
conditions.isTrendRejectUp = xcaConditions.isTrendRejectUp;
|
|
conditions.isTrendRejectDown = xcaConditions.isTrendRejectDown;
|
|
conditions.isSupportSameLast = xcaConditions.isSupportSameLast;
|
|
conditions.isSupportOverLast = xcaConditions.isSupportOverLast;
|
|
conditions.isSupportUnderLast = xcaConditions.isSupportUnderLast;
|
|
conditions.isSwingLowSameLast = xcaConditions.isSwingLowSameLast;
|
|
conditions.isSwingLowOverLast = xcaConditions.isSwingLowOverLast;
|
|
conditions.isSwingLowUnderLast = xcaConditions.isSwingLowUnderLast;
|
|
conditions.isSwingHighSameLast = xcaConditions.isSwingHighSameLast;
|
|
conditions.isSwingHighOverLast = xcaConditions.isSwingHighOverLast;
|
|
conditions.isSupportSameAsVale = xcaConditions.isSupportSameAsVale;
|
|
conditions.isLastSupportBreaked = xcaConditions.isLastSupportBreaked;
|
|
conditions.isResistanceSameLast = xcaConditions.isResistanceSameLast;
|
|
conditions.isResistanceOverLast = xcaConditions.isResistanceOverLast;
|
|
conditions.isSwingHighUnderLast = xcaConditions.isSwingHighUnderLast;
|
|
conditions.isSwingLowSameAsVale = xcaConditions.isSwingLowSameAsVale;
|
|
conditions.isLastSupportRejected = xcaConditions.isLastSupportRejected;
|
|
conditions.isResistanceUnderLast = xcaConditions.isResistanceUnderLast;
|
|
conditions.isKISwitchedToBullish = xcaConditions.isKISwitchedToBullish;
|
|
conditions.isKISwitchedToBearish = xcaConditions.isKISwitchedToBearish;
|
|
conditions.isLastSwingLowBreaked = xcaConditions.isLastSwingLowBreaked;
|
|
conditions.isSwingHighSameAsPeak = xcaConditions.isSwingHighSameAsPeak;
|
|
conditions.isTKISwitchedToBullish = xcaConditions.isTKISwitchedToBullish;
|
|
conditions.isTKISwitchedToBearish = xcaConditions.isTKISwitchedToBearish;
|
|
conditions.isLastSwingLowRejected = xcaConditions.isLastSwingLowRejected;
|
|
conditions.isSarSwitchedToBullish = xcaConditions.isSarSwitchedToBullish;
|
|
conditions.isSarSwitchedToBearish = xcaConditions.isSarSwitchedToBearish;
|
|
conditions.isLastSwingHighBreaked = xcaConditions.isLastSwingHighBreaked;
|
|
conditions.isResistanceSameAsPeak = xcaConditions.isResistanceSameAsPeak;
|
|
conditions.isLastSwingHighRejected = xcaConditions.isLastSwingHighRejected;
|
|
conditions.isLastResistanceBreaked = xcaConditions.isLastResistanceBreaked;
|
|
conditions.isSupportSameAsSwingLow = xcaConditions.isSupportSameAsSwingLow;
|
|
conditions.isLastResistanceRejected = xcaConditions.isLastResistanceRejected;
|
|
conditions.isTrendSwitchedToBullish = xcaConditions.isTrendSwitchedToBullish;
|
|
conditions.isTrendSwitchedToBearish = xcaConditions.isTrendSwitchedToBearish;
|
|
conditions.isResistanceSameAsSwingHigh = xcaConditions.isResistanceSameAsSwingHigh;
|
|
|
|
//
|
|
// XOSCS ...
|
|
|
|
//
|
|
// Buffers ...
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.acBuffer,
|
|
conditions.acBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.adBuffer,
|
|
conditions.adBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.atrBuffer,
|
|
conditions.atrBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.cciBuffer,
|
|
conditions.cciBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.rsiBuffer,
|
|
conditions.rsiBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.mfiBuffer,
|
|
conditions.mfiBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.rviBuffer,
|
|
conditions.rviBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.adxBuffer,
|
|
conditions.adxBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.adxpBuffer,
|
|
conditions.adxpBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.adxnBuffer,
|
|
conditions.adxnBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.macdBuffer,
|
|
conditions.macdBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.momentumBuffer,
|
|
conditions.momentumBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.rviSignalBuffer,
|
|
conditions.rviSignalBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.macdSignalBuffer,
|
|
conditions.macdSignalBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.stochasticBuffer,
|
|
conditions.stochasticBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xocsConditions.stochasticSignalBuffer,
|
|
conditions.stochasticSignalBuffer //
|
|
);
|
|
|
|
//
|
|
// Conditions ...
|
|
//
|
|
conditions.isCCIOB = xocsConditions.isCCIOB;
|
|
conditions.isCCIOS = xocsConditions.isCCIOS;
|
|
conditions.isRSIOB = xocsConditions.isRSIOB;
|
|
conditions.isRSIOS = xocsConditions.isRSIOS;
|
|
conditions.isMFIOB = xocsConditions.isMFIOB;
|
|
conditions.isMFIOS = xocsConditions.isMFIOS;
|
|
conditions.isACBullish = xocsConditions.isACBullish;
|
|
conditions.isACBearish = xocsConditions.isACBearish;
|
|
conditions.isACOverMax = xocsConditions.isACOverMax;
|
|
conditions.isADOverMax = xocsConditions.isADOverMax;
|
|
conditions.isACUnderMin = xocsConditions.isACUnderMin;
|
|
conditions.isADUnderMin = xocsConditions.isADUnderMin;
|
|
conditions.isADXBullish = xocsConditions.isADXBullish;
|
|
conditions.isADXBearish = xocsConditions.isADXBearish;
|
|
conditions.isCCIBullish = xocsConditions.isCCIBullish;
|
|
conditions.isCCIBearish = xocsConditions.isCCIBearish;
|
|
conditions.isRSIBullish = xocsConditions.isRSIBullish;
|
|
conditions.isRSIBearish = xocsConditions.isRSIBearish;
|
|
conditions.isMFIBullish = xocsConditions.isMFIBullish;
|
|
conditions.isMFIBearish = xocsConditions.isMFIBearish;
|
|
conditions.isRVIBullish = xocsConditions.isRVIBullish;
|
|
conditions.isRVIBearish = xocsConditions.isRVIBearish;
|
|
conditions.isATROverLast = xocsConditions.isATROverLast;
|
|
conditions.isMACDBullish = xocsConditions.isMACDBullish;
|
|
conditions.isMACDBearish = xocsConditions.isMACDBearish;
|
|
conditions.isATRUnderLast = xocsConditions.isATRUnderLast;
|
|
conditions.isADBiggerLast = xocsConditions.isADBiggerLast;
|
|
conditions.isADLesserLast = xocsConditions.isADLesserLast;
|
|
conditions.isStochasticOB = xocsConditions.isStochasticOB;
|
|
conditions.isStochasticOS = xocsConditions.isStochasticOS;
|
|
conditions.isADXBiggerLast = xocsConditions.isADXBiggerLast;
|
|
conditions.isADXLesserLast = xocsConditions.isADXLesserLast;
|
|
conditions.isRVIOverSignal = xocsConditions.isRVIOverSignal;
|
|
conditions.isRVIUnderSignal = xocsConditions.isRVIUnderSignal;
|
|
conditions.isMACDOverSignal = xocsConditions.isMACDOverSignal;
|
|
conditions.isMACDUnderSignal = xocsConditions.isMACDUnderSignal;
|
|
conditions.isMomentumBullish = xocsConditions.isMomentumBullish;
|
|
conditions.isMomentumBearish = xocsConditions.isMomentumBearish;
|
|
conditions.isADXOverThreshold = xocsConditions.isADXOverThreshold;
|
|
conditions.isDXPBiggerThanDXN = xocsConditions.isDXPBiggerThanDXN;
|
|
conditions.isDXNBiggerThanDXP = xocsConditions.isDXNBiggerThanDXP;
|
|
conditions.isCCICrossedOverOB = xocsConditions.isCCICrossedOverOB;
|
|
conditions.isCCICrossedOverOS = xocsConditions.isCCICrossedOverOS;
|
|
conditions.isRSICrossedOverOB = xocsConditions.isRSICrossedOverOB;
|
|
conditions.isRSICrossedOverOS = xocsConditions.isRSICrossedOverOS;
|
|
conditions.isMFICrossedOverOB = xocsConditions.isMFICrossedOverOB;
|
|
conditions.isMFICrossedOverOS = xocsConditions.isMFICrossedOverOS;
|
|
conditions.isADXUnderThreshold = xocsConditions.isADXUnderThreshold;
|
|
conditions.isCCICrossedUnderOB = xocsConditions.isCCICrossedUnderOB;
|
|
conditions.isCCICrossedUnderOS = xocsConditions.isCCICrossedUnderOS;
|
|
conditions.isRSICrossedUnderOB = xocsConditions.isRSICrossedUnderOB;
|
|
conditions.isRSICrossedUnderOS = xocsConditions.isRSICrossedUnderOS;
|
|
conditions.isMFICrossedUnderOB = xocsConditions.isMFICrossedUnderOB;
|
|
conditions.isMFICrossedUnderOS = xocsConditions.isMFICrossedUnderOS;
|
|
conditions.isStochasticBullish = xocsConditions.isStochasticBullish;
|
|
conditions.isStochasticBearish = xocsConditions.isStochasticBearish;
|
|
conditions.isACSwitchedToBullish = xocsConditions.isACSwitchedToBullish;
|
|
conditions.isACSwitchedToBearish = xocsConditions.isACSwitchedToBearish;
|
|
conditions.isADXSwitchedToBullish = xocsConditions.isADXSwitchedToBullish;
|
|
conditions.isADXSwitchedToBearish = xocsConditions.isADXSwitchedToBearish;
|
|
conditions.isCCISwitchedToBullish = xocsConditions.isCCISwitchedToBullish;
|
|
conditions.isCCISwitchedToBearish = xocsConditions.isCCISwitchedToBearish;
|
|
conditions.isRSISwitchedToBullish = xocsConditions.isRSISwitchedToBullish;
|
|
conditions.isRSISwitchedToBearish = xocsConditions.isRSISwitchedToBearish;
|
|
conditions.isMFISwitchedToBullish = xocsConditions.isMFISwitchedToBullish;
|
|
conditions.isMFISwitchedToBearish = xocsConditions.isMFISwitchedToBearish;
|
|
conditions.isRVISwitchedToBullish = xocsConditions.isRVISwitchedToBullish;
|
|
conditions.isRVISwitchedToBearish = xocsConditions.isRVISwitchedToBearish;
|
|
conditions.isRVICrossedOverSignal = xocsConditions.isRVICrossedOverSignal;
|
|
conditions.isStochasticOverSignal = xocsConditions.isStochasticOverSignal;
|
|
conditions.isStochasticUnderSignal = xocsConditions.isStochasticUnderSignal;
|
|
conditions.isRVICrossedUnderSignal = xocsConditions.isRVICrossedUnderSignal;
|
|
conditions.isMACDSwitchedToBullish = xocsConditions.isMACDSwitchedToBullish;
|
|
conditions.isMACDSwitchedToBearish = xocsConditions.isMACDSwitchedToBearish;
|
|
conditions.isMACDCrossedOverSignal = xocsConditions.isMACDCrossedOverSignal;
|
|
conditions.isMACDCrossedUnderSignal = xocsConditions.isMACDCrossedUnderSignal;
|
|
conditions.isStochasticCrossedOverOB = xocsConditions.isStochasticCrossedOverOB;
|
|
conditions.isStochasticCrossedOverOS = xocsConditions.isStochasticCrossedOverOS;
|
|
conditions.isStochasticCrossedUnderOB = xocsConditions.isStochasticCrossedUnderOB;
|
|
conditions.isStochasticCrossedUnderOS = xocsConditions.isStochasticCrossedUnderOS;
|
|
conditions.isMomentumSwitchedToBullish = xocsConditions.isMomentumSwitchedToBullish;
|
|
conditions.isMomentumSwitchedToBearish = xocsConditions.isMomentumSwitchedToBearish;
|
|
conditions.isStochasticSwitchedToBullish = xocsConditions.isStochasticSwitchedToBullish;
|
|
conditions.isStochasticSwitchedToBearish = xocsConditions.isStochasticSwitchedToBearish;
|
|
conditions.isStochasticCrossedOverSignal = xocsConditions.isStochasticCrossedOverSignal;
|
|
conditions.isStochasticCrossedUnderSignal = xocsConditions.isStochasticCrossedUnderSignal;
|
|
|
|
//
|
|
// Cleanup Resource ...
|
|
|
|
//
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
fromBar.Clean();
|
|
|
|
//
|
|
xcaConditions.Clean();
|
|
xocsConditions.Clean();
|
|
|
|
//
|
|
Free();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Protected ...
|
|
protected:
|
|
//
|
|
// Private ...
|
|
private:
|
|
//
|
|
// Props ...
|
|
|
|
//
|
|
string mSymbol; // Trading Symbol
|
|
ENUM_TIMEFRAMES mPeriod; // Trading Period
|
|
|
|
//
|
|
// Inputs ...
|
|
XCAEAInputs mInputs;
|
|
|
|
//
|
|
// Handlers ...
|
|
int acHandler;
|
|
int adHandler;
|
|
int adxHandler;
|
|
int atrHandler;
|
|
int cciHandler;
|
|
int rsiHandler;
|
|
int mfiHandler;
|
|
int rviHandler;
|
|
int macdHandler;
|
|
int momentumHandler;
|
|
int stochasticHandler;
|
|
};
|
|
|
|
// |