4822 lines
127 KiB
Plaintext
4822 lines
127 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.x3ma.helper.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;
|
|
X121X3MAInputs x3maInputs;
|
|
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();
|
|
x3maInputs.Clean();
|
|
oscsInputs.Clean();
|
|
|
|
//
|
|
ZeroMemory(this);
|
|
}
|
|
|
|
/**
|
|
* Set Default Values ...
|
|
*/
|
|
void Default()
|
|
{
|
|
//
|
|
ctInputs.Default();
|
|
ccInputs.Default();
|
|
caInputs.Default();
|
|
x3maInputs.Default();
|
|
oscsInputs.Default();
|
|
}
|
|
|
|
/**
|
|
* Hide all Visibles ...
|
|
*/
|
|
void Hide()
|
|
{
|
|
//
|
|
ctInputs.Hide();
|
|
caInputs.Hide();
|
|
x3maInputs.Hide();
|
|
}
|
|
|
|
/**
|
|
* Validate ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsValid()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result =
|
|
//
|
|
ctInputs.IsValid() &&
|
|
ccInputs.IsValid() &&
|
|
caInputs.IsValid() &&
|
|
x3maInputs.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();
|
|
int x3maMax = x3maInputs.Max();
|
|
|
|
//
|
|
result = MathMax(ctMax, ccMax);
|
|
result = MathMax(result, caMax);
|
|
result = MathMax(result, ocsMax);
|
|
result = MathMax(result, x3maMax);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
};
|
|
|
|
//
|
|
// Conditions Structure ...
|
|
struct XCAEAConditions
|
|
{
|
|
//
|
|
// Common ...
|
|
string symbol;
|
|
ENUM_TIMEFRAMES period;
|
|
datetime time;
|
|
|
|
//
|
|
datetime to;
|
|
datetime from;
|
|
|
|
//
|
|
// Bars ...
|
|
XOHCL bars[];
|
|
double bodies[];
|
|
double ranges[];
|
|
double velocities[];
|
|
double scoreBullish;
|
|
double scoreBearish;
|
|
double volumeBullish;
|
|
double volumeBearish;
|
|
double priceChangeRate;
|
|
bool bullishEngulfedBars[];
|
|
bool bearishEngulfedBars[];
|
|
bool bullishRejectedBars[];
|
|
bool bearishRejectedBars[];
|
|
|
|
//
|
|
// X3MA ...
|
|
|
|
//
|
|
// Buffers ...
|
|
|
|
//
|
|
double fastBuffer[];
|
|
double mediumBuffer[];
|
|
double slowBuffer[];
|
|
double fastStateBuffer[];
|
|
double mediumStateBuffer[];
|
|
double slowStateBuffer[];
|
|
|
|
//
|
|
// Conditions ...
|
|
|
|
//
|
|
bool isFastOverMedium;
|
|
bool isFastUnderMedium;
|
|
|
|
//
|
|
bool isFastCrossedOverMedium;
|
|
bool isFastCrossedUnderMedium;
|
|
|
|
//
|
|
bool isFastOverSlow;
|
|
bool isFastUnderSlow;
|
|
|
|
//
|
|
bool isFastCrossedOverSlow;
|
|
bool isFastCrossedUnderSlow;
|
|
|
|
//
|
|
bool isMediumOverSlow;
|
|
bool isMediumUnderSlow;
|
|
|
|
//
|
|
bool isMediumCrossedOverSlow;
|
|
bool isMediumCrossedUnderSlow;
|
|
|
|
//
|
|
bool is3MaBullishOrdered;
|
|
bool is3MaBearishOrdered;
|
|
|
|
//
|
|
bool is3MaSwitchedToBullishOrdered;
|
|
bool is3MaSwitchedToBearishOrdered;
|
|
|
|
//
|
|
bool is3MaBullishState;
|
|
bool is3MaBearishState;
|
|
|
|
//
|
|
bool is3MaSwitchedToBullishState;
|
|
bool is3MaSwitchedToBearishState;
|
|
|
|
//
|
|
bool is3MaBullish;
|
|
bool is3MaBearish;
|
|
|
|
//
|
|
bool is3MaSwitchedToBullish;
|
|
bool is3MaSwitchedToBearish;
|
|
|
|
//
|
|
bool is3MaFinishedFromBullish;
|
|
bool is3MaFinishedFromBearish;
|
|
|
|
//
|
|
// 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 mahBuffer[];
|
|
double malBuffer[];
|
|
double macBuffer[];
|
|
double peakBuffer[];
|
|
double valeBuffer[];
|
|
double vidyaBuffer[];
|
|
double trendBuffer[];
|
|
double kiStateBuffer[];
|
|
double supportBuffer[];
|
|
double tkiStateBuffer[];
|
|
double swingLowBuffer[];
|
|
double swingHighBuffer[];
|
|
double vidyaStateBuffer[];
|
|
double resistanceBuffer[];
|
|
double peakGoldenBuffer[];
|
|
double valeGoldenBuffer[];
|
|
double fiboLevel1Buffer[];
|
|
double fiboLevel2Buffer[];
|
|
double fiboLevel3Buffer[];
|
|
double fiboLevel4Buffer[];
|
|
double fiboLevel5Buffer[];
|
|
double trendStateBuffer[];
|
|
|
|
//
|
|
// Conditions ...
|
|
|
|
//
|
|
// KI ...
|
|
|
|
//
|
|
bool isKIRejectUp;
|
|
bool isKIRejectDown;
|
|
|
|
//
|
|
bool isKIBullish;
|
|
bool isKIBearish;
|
|
|
|
//
|
|
bool isKISwitchedToBullish;
|
|
bool isKISwitchedToBearish;
|
|
|
|
//
|
|
bool isKIFinishedFromBullish;
|
|
bool isKIFinishedFromBearish;
|
|
|
|
//
|
|
// TKI ...
|
|
|
|
//
|
|
bool isTKIRejectUp;
|
|
bool isTKIRejectDown;
|
|
|
|
//
|
|
bool isTKIBullish;
|
|
bool isTKIBearish;
|
|
|
|
//
|
|
bool isTKISwitchedToBullish;
|
|
bool isTKISwitchedToBearish;
|
|
|
|
//
|
|
bool isTKIFinishedFromBullish;
|
|
bool isTKIFinishedFromBearish;
|
|
|
|
//
|
|
// VIDYA ...
|
|
|
|
//
|
|
bool isVidyaRejectUp;
|
|
bool isVidyaRejectDown;
|
|
|
|
//
|
|
bool isVidyaBullish;
|
|
bool isVidyaBearish;
|
|
|
|
//
|
|
bool isVidyaSwitchedToBullish;
|
|
bool isVidyaSwitchedToBearish;
|
|
|
|
//
|
|
bool isVidyaFinishedFromBullish;
|
|
bool isVidyaFinishedFromBearish;
|
|
|
|
//
|
|
// SAR ...
|
|
|
|
//
|
|
bool isSarBullish;
|
|
bool isSarBearish;
|
|
|
|
//
|
|
bool isSarSwitchedToBullish;
|
|
bool isSarSwitchedToBearish;
|
|
|
|
//
|
|
bool isSarFinishedFromBullish;
|
|
bool isSarFinishedFromBearish;
|
|
|
|
//
|
|
// MANALYSER ...
|
|
|
|
//
|
|
// MAH ...
|
|
|
|
//
|
|
bool isOverMah;
|
|
bool isUnderMah;
|
|
bool isCrossedOverMah;
|
|
bool isCrossedUnderMah;
|
|
|
|
//
|
|
bool isCloseOverMah;
|
|
bool isCloseUnderMah;
|
|
bool isCloseCrossedOverMah;
|
|
bool isCloseCrossedUnderMah;
|
|
|
|
//
|
|
bool isMahBullishRejected;
|
|
bool isMahBearishRejected;
|
|
|
|
//
|
|
// MAL ...
|
|
|
|
//
|
|
bool isOverMal;
|
|
bool isUnderMal;
|
|
bool isCrossedOverMal;
|
|
bool isCrossedUnderMal;
|
|
|
|
//
|
|
bool isCloseOverMal;
|
|
bool isCloseUnderMal;
|
|
bool isCloseCrossedOverMal;
|
|
bool isCloseCrossedUnderMal;
|
|
|
|
//
|
|
bool isMalBullishRejected;
|
|
bool isMalBearishRejected;
|
|
|
|
//
|
|
// MAC ...
|
|
|
|
//
|
|
bool isOverMac;
|
|
bool isUnderMac;
|
|
bool isCrossedOverMac;
|
|
bool isCrossedUnderMac;
|
|
|
|
//
|
|
bool isCloseOverMac;
|
|
bool isCloseUnderMac;
|
|
bool isCloseCrossedOverMac;
|
|
bool isCloseCrossedUnderMac;
|
|
|
|
//
|
|
bool isMacBullishRejected;
|
|
bool isMacBearishRejected;
|
|
|
|
//
|
|
// 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;
|
|
|
|
//
|
|
bool isTrendFinishedFromBullish;
|
|
bool isTrendFinishedFromBearish;
|
|
|
|
//
|
|
// 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 isPeakSwitchedToPivot;
|
|
bool isValeSwitchedToPivot;
|
|
|
|
//
|
|
bool isPeakFinishedFromPivot;
|
|
bool isValeFinishedFromPivot;
|
|
|
|
//
|
|
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[];
|
|
|
|
//
|
|
// Values ...
|
|
|
|
//
|
|
double adxThreshold;
|
|
double cciOBLevel;
|
|
double cciOSLevel;
|
|
double cciReversalLevel;
|
|
double rsiOBLevel;
|
|
double rsiOSLevel;
|
|
double rsiReversalLevel;
|
|
double mfiOBLevel;
|
|
double mfiOSLevel;
|
|
double mfiReversalLevel;
|
|
double rviBullishLevel;
|
|
double rviBearishLevel;
|
|
double macdBullishLevel;
|
|
double macdBearishLevel;
|
|
double momentumBullishLevel;
|
|
double momentumBearishLevel;
|
|
double stochasticOBLevel;
|
|
double stochasticOSLevel;
|
|
double stochasticReversalLevel;
|
|
|
|
//
|
|
// 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;
|
|
|
|
//
|
|
// Bars ...
|
|
Clean(bars);
|
|
Clean(bodies);
|
|
Clean(ranges);
|
|
scoreBullish = 0;
|
|
scoreBearish = 0;
|
|
volumeBullish = 0;
|
|
volumeBearish = 0;
|
|
Clean(velocities);
|
|
priceChangeRate = 0;
|
|
Clean(bullishEngulfedBars);
|
|
Clean(bearishEngulfedBars);
|
|
Clean(bullishRejectedBars);
|
|
Clean(bearishRejectedBars);
|
|
ArraySetAsSeries(bars, true);
|
|
ArraySetAsSeries(bodies, true);
|
|
ArraySetAsSeries(ranges, true);
|
|
ArraySetAsSeries(velocities, true);
|
|
ArraySetAsSeries(bullishEngulfedBars, true);
|
|
ArraySetAsSeries(bearishEngulfedBars, true);
|
|
ArraySetAsSeries(bullishRejectedBars, true);
|
|
ArraySetAsSeries(bearishRejectedBars, true);
|
|
|
|
//
|
|
// X3MA ...
|
|
|
|
//
|
|
// Buffers ...
|
|
|
|
//
|
|
Clean(fastBuffer);
|
|
Clean(mediumBuffer);
|
|
Clean(slowBuffer);
|
|
Clean(fastStateBuffer);
|
|
Clean(mediumStateBuffer);
|
|
Clean(slowStateBuffer);
|
|
|
|
//
|
|
ArraySetAsSeries(fastBuffer, true);
|
|
ArraySetAsSeries(mediumBuffer, true);
|
|
ArraySetAsSeries(slowBuffer, true);
|
|
ArraySetAsSeries(fastStateBuffer, true);
|
|
ArraySetAsSeries(mediumStateBuffer, true);
|
|
ArraySetAsSeries(slowStateBuffer, true);
|
|
|
|
//
|
|
// Conditions ...
|
|
|
|
//
|
|
isFastOverMedium = false;
|
|
isFastUnderMedium = false;
|
|
|
|
//
|
|
isFastCrossedOverMedium = false;
|
|
isFastCrossedUnderMedium = false;
|
|
|
|
//
|
|
isFastOverSlow = false;
|
|
isFastUnderSlow = false;
|
|
|
|
//
|
|
isFastCrossedOverSlow = false;
|
|
isFastCrossedUnderSlow = false;
|
|
|
|
//
|
|
isMediumOverSlow = false;
|
|
isMediumUnderSlow = false;
|
|
|
|
//
|
|
isMediumCrossedOverSlow = false;
|
|
isMediumCrossedUnderSlow = false;
|
|
|
|
//
|
|
is3MaBullishOrdered = false;
|
|
is3MaBearishOrdered = false;
|
|
|
|
//
|
|
is3MaSwitchedToBullishOrdered = false;
|
|
is3MaSwitchedToBearishOrdered = false;
|
|
|
|
//
|
|
is3MaBullishState = false;
|
|
is3MaBearishState = false;
|
|
|
|
//
|
|
is3MaSwitchedToBullishState = false;
|
|
is3MaSwitchedToBearishState = false;
|
|
|
|
//
|
|
is3MaBullish = false;
|
|
is3MaBearish = false;
|
|
|
|
//
|
|
is3MaSwitchedToBullish = false;
|
|
is3MaSwitchedToBearish = false;
|
|
|
|
//
|
|
is3MaFinishedFromBullish = false;
|
|
is3MaFinishedFromBearish = false;
|
|
|
|
//
|
|
// 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(mahBuffer);
|
|
Clean(malBuffer);
|
|
Clean(macBuffer);
|
|
Clean(peakBuffer);
|
|
Clean(valeBuffer);
|
|
Clean(vidyaBuffer);
|
|
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(fiboLevel4Buffer);
|
|
Clean(fiboLevel5Buffer);
|
|
Clean(vidyaStateBuffer);
|
|
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(mahBuffer, true);
|
|
ArraySetAsSeries(malBuffer, true);
|
|
ArraySetAsSeries(macBuffer, true);
|
|
ArraySetAsSeries(peakBuffer, true);
|
|
ArraySetAsSeries(valeBuffer, true);
|
|
ArraySetAsSeries(vidyaBuffer, 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(fiboLevel4Buffer, true);
|
|
ArraySetAsSeries(fiboLevel5Buffer, true);
|
|
ArraySetAsSeries(vidyaStateBuffer, true);
|
|
ArraySetAsSeries(trendStateBuffer, true);
|
|
|
|
//
|
|
// Conditions ...
|
|
|
|
//
|
|
// KI ...
|
|
|
|
//
|
|
isKIRejectUp = false;
|
|
isKIRejectDown = false;
|
|
|
|
//
|
|
isKIBullish = false;
|
|
isKIBearish = false;
|
|
|
|
//
|
|
isKISwitchedToBullish = false;
|
|
isKISwitchedToBearish = false;
|
|
|
|
//
|
|
isKIFinishedFromBullish = false;
|
|
isKIFinishedFromBearish = false;
|
|
|
|
//
|
|
// TKI ...
|
|
|
|
//
|
|
isTKIRejectUp = false;
|
|
isTKIRejectDown = false;
|
|
|
|
//
|
|
isTKIBullish = false;
|
|
isTKIBearish = false;
|
|
|
|
//
|
|
isTKISwitchedToBullish = false;
|
|
isTKISwitchedToBearish = false;
|
|
|
|
//
|
|
isTKIFinishedFromBullish = false;
|
|
isTKIFinishedFromBearish = false;
|
|
|
|
//
|
|
// VIDYA ...
|
|
|
|
//
|
|
isVidyaRejectUp = false;
|
|
isVidyaRejectDown = false;
|
|
|
|
//
|
|
isVidyaBullish = false;
|
|
isVidyaBearish = false;
|
|
|
|
//
|
|
isVidyaSwitchedToBullish = false;
|
|
isVidyaSwitchedToBearish = false;
|
|
|
|
//
|
|
isVidyaFinishedFromBullish = false;
|
|
isVidyaFinishedFromBearish = false;
|
|
|
|
//
|
|
// SAR ...
|
|
|
|
//
|
|
isSarBullish = false;
|
|
isSarBearish = false;
|
|
|
|
//
|
|
isSarSwitchedToBullish = false;
|
|
isSarSwitchedToBearish = false;
|
|
|
|
//
|
|
isSarFinishedFromBullish = false;
|
|
isSarFinishedFromBearish = false;
|
|
|
|
//
|
|
// MANALYSER ...
|
|
|
|
//
|
|
// MAH ...
|
|
|
|
//
|
|
isOverMah = false;
|
|
isUnderMah = false;
|
|
isCrossedOverMah = false;
|
|
isCrossedUnderMah = false;
|
|
|
|
//
|
|
isCloseOverMah = false;
|
|
isCloseUnderMah = false;
|
|
isCloseCrossedOverMah = false;
|
|
isCloseCrossedUnderMah = false;
|
|
|
|
//
|
|
isMahBullishRejected = false;
|
|
isMahBearishRejected = false;
|
|
|
|
//
|
|
// MAL ...
|
|
|
|
//
|
|
isOverMal = false;
|
|
isUnderMal = false;
|
|
isCrossedOverMal = false;
|
|
isCrossedUnderMal = false;
|
|
|
|
//
|
|
isCloseOverMal = false;
|
|
isCloseUnderMal = false;
|
|
isCloseCrossedOverMal = false;
|
|
isCloseCrossedUnderMal = false;
|
|
|
|
//
|
|
isMalBullishRejected = false;
|
|
isMalBearishRejected = false;
|
|
|
|
//
|
|
// MAC ...
|
|
|
|
//
|
|
isOverMac = false;
|
|
isUnderMac = false;
|
|
isCrossedOverMac = false;
|
|
isCrossedUnderMac = false;
|
|
|
|
//
|
|
isCloseOverMac = false;
|
|
isCloseUnderMac = false;
|
|
isCloseCrossedOverMac = false;
|
|
isCloseCrossedUnderMac = false;
|
|
|
|
//
|
|
isMacBullishRejected = false;
|
|
isMacBearishRejected = 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;
|
|
|
|
//
|
|
isTrendFinishedFromBullish = false;
|
|
isTrendFinishedFromBearish = 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;
|
|
|
|
//
|
|
isPeakSwitchedToPivot = false;
|
|
isValeSwitchedToPivot = false;
|
|
|
|
//
|
|
isPeakFinishedFromPivot = false;
|
|
isValeFinishedFromPivot = 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);
|
|
|
|
//
|
|
// Values ...
|
|
|
|
//
|
|
adxThreshold = 0.0;
|
|
cciOBLevel = 0.0;
|
|
cciOSLevel = 0.0;
|
|
cciReversalLevel = 0.0;
|
|
rsiOBLevel = 0.0;
|
|
rsiOSLevel = 0.0;
|
|
rsiReversalLevel = 0.0;
|
|
mfiOBLevel = 0.0;
|
|
mfiOSLevel = 0.0;
|
|
mfiReversalLevel = 0.0;
|
|
rviBullishLevel = 0.0;
|
|
rviBearishLevel = 0.0;
|
|
macdBullishLevel = 0.0;
|
|
macdBearishLevel = 0.0;
|
|
momentumBullishLevel = 0.0;
|
|
momentumBearishLevel = 0.0;
|
|
stochasticOBLevel = 0.0;
|
|
stochasticOSLevel = 0.0;
|
|
stochasticReversalLevel = 0.0;
|
|
|
|
//
|
|
// 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;
|
|
|
|
//
|
|
// X3MA ...
|
|
|
|
//
|
|
// XCA ...
|
|
|
|
//
|
|
if (isFastOverSlow)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isFastOverMedium)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isMediumOverSlow)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isFastCrossedOverSlow)
|
|
{
|
|
bullishScore += score;
|
|
}
|
|
if (isFastCrossedOverMedium)
|
|
{
|
|
bullishScore += score;
|
|
}
|
|
if (isMediumCrossedOverSlow)
|
|
{
|
|
bullishScore += score;
|
|
}
|
|
|
|
//
|
|
if (is3MaBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (is3MaBullishState)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (is3MaBullishOrdered)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (is3MaSwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (is3MaFinishedFromBearish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (is3MaSwitchedToBullishState)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (is3MaSwitchedToBullishOrdered)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isFastUnderSlow)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isMediumUnderSlow)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isFastUnderMedium)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isFastCrossedUnderSlow)
|
|
{
|
|
bearishScore += score;
|
|
}
|
|
if (isFastCrossedUnderMedium)
|
|
{
|
|
bearishScore += score;
|
|
}
|
|
if (isMediumCrossedUnderSlow)
|
|
{
|
|
bearishScore += score;
|
|
}
|
|
|
|
//
|
|
if (is3MaBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (is3MaBearishState)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (is3MaBearishOrdered)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (is3MaSwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (is3MaFinishedFromBullish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (is3MaSwitchedToBearishState)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (is3MaSwitchedToBearishOrdered)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
//
|
|
// 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;
|
|
}
|
|
|
|
//
|
|
// VIDYA ...
|
|
|
|
//
|
|
if (isVidyaBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isVidyaRejectUp)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isVidyaSwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isVidyaBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isVidyaRejectDown)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isVidyaSwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// SAR ...
|
|
|
|
//
|
|
if (isSarBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isSarSwitchedToBullish)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isSarBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isSarSwitchedToBearish)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// MANALYSER ...
|
|
|
|
//
|
|
// MAH ...
|
|
|
|
//
|
|
if (isUnderMah)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isCloseUnderMah)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isCrossedUnderMah)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isMahBullishRejected)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isCloseCrossedUnderMah)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isOverMah)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isCloseOverMah)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isCrossedOverMah)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isMahBearishRejected)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isCloseCrossedOverMah)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
|
|
//
|
|
// MAL ...
|
|
|
|
//
|
|
if (isOverMal)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isCloseOverMal)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isCrossedOverMal)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isMalBullishRejected)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isCloseCrossedOverMal)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isUnderMal)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isCloseUnderMal)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isCrossedUnderMal)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isMalBearishRejected)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isCloseCrossedUnderMal)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
|
|
//
|
|
// MAC ...
|
|
|
|
//
|
|
if (isOverMac)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isCloseOverMac)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isCrossedOverMac)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isMacBullishRejected)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
if (isCloseCrossedOverMac)
|
|
{
|
|
bullishScore += minScore;
|
|
}
|
|
|
|
//
|
|
if (isUnderMac)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isCloseUnderMac)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isCrossedUnderMac)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isMacBearishRejected)
|
|
{
|
|
bearishScore += minScore;
|
|
}
|
|
if (isCloseCrossedUnderMac)
|
|
{
|
|
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 +
|
|
"X3MA: " + separator +
|
|
"-----------------------" + separator +
|
|
ToString("isFastOverMedium", isFastOverMedium, ignoreFalseConditions, separator) +
|
|
ToString("isFastUnderMedium", isFastUnderMedium, ignoreFalseConditions, separator) +
|
|
ToString("isFastCrossedOverMedium", isFastCrossedOverMedium, ignoreFalseConditions, separator) +
|
|
ToString("isFastCrossedUnderMedium", isFastCrossedUnderMedium, ignoreFalseConditions, separator) +
|
|
ToString("isFastOverSlow", isFastOverSlow, ignoreFalseConditions, separator) +
|
|
ToString("isFastUnderSlow", isFastUnderSlow, ignoreFalseConditions, separator) +
|
|
ToString("isFastCrossedOverSlow", isFastCrossedOverSlow, ignoreFalseConditions, separator) +
|
|
ToString("isFastCrossedUnderSlow", isFastCrossedUnderSlow, ignoreFalseConditions, separator) +
|
|
ToString("isMediumOverSlow", isMediumOverSlow, ignoreFalseConditions, separator) +
|
|
ToString("isMediumUnderSlow", isMediumUnderSlow, ignoreFalseConditions, separator) +
|
|
ToString("isMediumCrossedOverSlow", isMediumCrossedOverSlow, ignoreFalseConditions, separator) +
|
|
ToString("isMediumCrossedUnderSlow", isMediumCrossedUnderSlow, ignoreFalseConditions, separator) +
|
|
ToString("is3MaBullishOrdered", is3MaBullishOrdered, ignoreFalseConditions, separator) +
|
|
ToString("is3MaBearishOrdered", is3MaBearishOrdered, ignoreFalseConditions, separator) +
|
|
ToString("is3MaSwitchedToBullishOrdered", is3MaSwitchedToBullishOrdered, ignoreFalseConditions, separator) +
|
|
ToString("is3MaSwitchedToBearishOrdered", is3MaSwitchedToBearishOrdered, ignoreFalseConditions, separator) +
|
|
ToString("is3MaBullishState", is3MaBullishState, ignoreFalseConditions, separator) +
|
|
ToString("is3MaBearishState", is3MaBearishState, ignoreFalseConditions, separator) +
|
|
ToString("is3MaSwitchedToBullishState", is3MaSwitchedToBullishState, ignoreFalseConditions, separator) +
|
|
ToString("is3MaSwitchedToBearishState", is3MaSwitchedToBearishState, ignoreFalseConditions, separator) +
|
|
ToString("is3MaBullish", is3MaBullish, ignoreFalseConditions, separator) +
|
|
ToString("is3MaBearish", is3MaBearish, ignoreFalseConditions, separator) +
|
|
ToString("is3MaSwitchedToBullish", is3MaSwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("is3MaSwitchedToBearish", is3MaSwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("is3MaFinishedFromBullish", is3MaFinishedFromBullish, ignoreFalseConditions, separator) +
|
|
ToString("is3MaFinishedFromBearish", is3MaFinishedFromBearish, ignoreFalseConditions, separator) +
|
|
"-----------------------" + 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("isKIFinishedFromBullish", isKIFinishedFromBullish, ignoreFalseConditions, separator) +
|
|
ToString("isKISwitchedToBearish", isKISwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isKIFinishedFromBearish", isKIFinishedFromBearish, 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("isTKIFinishedFromBullish", isTKIFinishedFromBullish, ignoreFalseConditions, separator) +
|
|
ToString("isTKISwitchedToBearish", isTKISwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isTKIFinishedFromBearish", isTKIFinishedFromBearish, ignoreFalseConditions, separator) +
|
|
ToString("isVidyaRejectUp", isVidyaRejectUp, ignoreFalseConditions, separator) +
|
|
ToString("isVidyaRejectDown", isVidyaRejectDown, ignoreFalseConditions, separator) +
|
|
ToString("isVidyaBullish", isVidyaBullish, ignoreFalseConditions, separator) +
|
|
ToString("isVidyaBearish", isVidyaBearish, ignoreFalseConditions, separator) +
|
|
ToString("isVidyaSwitchedToBullish", isVidyaSwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isVidyaFinishedFromBullish", isVidyaFinishedFromBullish, ignoreFalseConditions, separator) +
|
|
ToString("isVidyaSwitchedToBearish", isVidyaSwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isVidyaFinishedFromBearish", isVidyaFinishedFromBearish, ignoreFalseConditions, separator) +
|
|
ToString("isSarBullish", isSarBullish, ignoreFalseConditions, separator) +
|
|
ToString("isSarBearish", isSarBearish, ignoreFalseConditions, separator) +
|
|
ToString("isSarSwitchedToBullish", isSarSwitchedToBullish, ignoreFalseConditions, separator) +
|
|
ToString("isSarFinishedFromBullish", isSarFinishedFromBullish, ignoreFalseConditions, separator) +
|
|
ToString("isSarSwitchedToBearish", isSarSwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isSarFinishedFromBearish", isSarFinishedFromBearish, ignoreFalseConditions, separator) +
|
|
ToString("isOverMah", isOverMah, ignoreFalseConditions, separator) +
|
|
ToString("isUnderMah", isUnderMah, ignoreFalseConditions, separator) +
|
|
ToString("isCrossedOverMah", isCrossedOverMah, ignoreFalseConditions, separator) +
|
|
ToString("isCrossedUnderMah", isCrossedUnderMah, ignoreFalseConditions, separator) +
|
|
ToString("isCloseOverMah", isCloseOverMah, ignoreFalseConditions, separator) +
|
|
ToString("isCloseUnderMah", isCloseUnderMah, ignoreFalseConditions, separator) +
|
|
ToString("isCloseCrossedOverMah", isCloseCrossedOverMah, ignoreFalseConditions, separator) +
|
|
ToString("isCloseCrossedUnderMah", isCloseCrossedUnderMah, ignoreFalseConditions, separator) +
|
|
ToString("isMahBullishRejected", isMahBullishRejected, ignoreFalseConditions, separator) +
|
|
ToString("isMahBearishRejected", isMahBearishRejected, ignoreFalseConditions, separator) +
|
|
ToString("isOverMal", isOverMal, ignoreFalseConditions, separator) +
|
|
ToString("isUnderMal", isUnderMal, ignoreFalseConditions, separator) +
|
|
ToString("isCrossedOverMal", isCrossedOverMal, ignoreFalseConditions, separator) +
|
|
ToString("isCrossedUnderMal", isCrossedUnderMal, ignoreFalseConditions, separator) +
|
|
ToString("isCloseOverMal", isCloseOverMal, ignoreFalseConditions, separator) +
|
|
ToString("isCloseUnderMal", isCloseUnderMal, ignoreFalseConditions, separator) +
|
|
ToString("isCloseCrossedOverMal", isCloseCrossedOverMal, ignoreFalseConditions, separator) +
|
|
ToString("isCloseCrossedUnderMal", isCloseCrossedUnderMal, ignoreFalseConditions, separator) +
|
|
ToString("isMalBullishRejected", isMalBullishRejected, ignoreFalseConditions, separator) +
|
|
ToString("isMalBearishRejected", isMalBearishRejected, ignoreFalseConditions, separator) +
|
|
ToString("isOverMac", isOverMac, ignoreFalseConditions, separator) +
|
|
ToString("isUnderMac", isUnderMac, ignoreFalseConditions, separator) +
|
|
ToString("isCrossedOverMac", isCrossedOverMac, ignoreFalseConditions, separator) +
|
|
ToString("isCrossedUnderMac", isCrossedUnderMac, ignoreFalseConditions, separator) +
|
|
ToString("isCloseOverMac", isCloseOverMac, ignoreFalseConditions, separator) +
|
|
ToString("isCloseUnderMac", isCloseUnderMac, ignoreFalseConditions, separator) +
|
|
ToString("isCloseCrossedOverMac", isCloseCrossedOverMac, ignoreFalseConditions, separator) +
|
|
ToString("isCloseCrossedUnderMac", isCloseCrossedUnderMac, ignoreFalseConditions, separator) +
|
|
ToString("isMacBullishRejected", isMacBullishRejected, ignoreFalseConditions, separator) +
|
|
ToString("isMacBearishRejected", isMacBearishRejected, 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("isTrendFinishedFromBullish", isTrendFinishedFromBullish, ignoreFalseConditions, separator) +
|
|
ToString("isTrendSwitchedToBearish", isTrendSwitchedToBearish, ignoreFalseConditions, separator) +
|
|
ToString("isTrendFinishedFromBearish", isTrendFinishedFromBearish, 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("isPeakSwitchedToPivot", isPeakSwitchedToPivot, ignoreFalseConditions, separator) +
|
|
ToString("isPeakFinishedFromPivot", isPeakFinishedFromPivot, ignoreFalseConditions, separator) +
|
|
ToString("isValeSwitchedToPivot", isValeSwitchedToPivot, ignoreFalseConditions, separator) +
|
|
ToString("isValeFinishedFromPivot", isValeFinishedFromPivot, 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) +
|
|
//
|
|
""
|
|
//
|
|
;
|
|
|
|
//
|
|
if (onlyCommons && !onlyConditions)
|
|
{
|
|
result += commonStr = separator;
|
|
}
|
|
else if (onlyConditions && !onlyCommons)
|
|
{
|
|
result += conditionsStr + separator;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
result +=
|
|
//
|
|
commonStr + separator +
|
|
conditionsStr + separator
|
|
//
|
|
;
|
|
}
|
|
|
|
//
|
|
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;
|
|
XCX121X3MAHelper *x3maHelper;
|
|
|
|
//
|
|
// Constructor ...
|
|
XCXCAEAHelper()
|
|
{
|
|
//
|
|
barAnalyser = new XCBarAnalyser();
|
|
}
|
|
|
|
//
|
|
// Deconstructor ...
|
|
~XCXCAEAHelper()
|
|
{
|
|
//
|
|
mInputs.Clean();
|
|
|
|
//
|
|
ZeroMemory(ccHelper);
|
|
ZeroMemory(ctHelper);
|
|
ZeroMemory(caHelper);
|
|
ZeroMemory(ocsHelper);
|
|
ZeroMemory(x3maHelper);
|
|
|
|
//
|
|
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 //
|
|
);
|
|
|
|
//
|
|
// X3MA ...
|
|
x3maHelper = new XCX121X3MAHelper();
|
|
result =
|
|
result &&
|
|
x3maHelper.Init(
|
|
symbol,
|
|
period,
|
|
mInputs.x3maInputs //
|
|
);
|
|
|
|
//
|
|
if (!result)
|
|
{
|
|
//
|
|
ZeroMemory(ccHelper);
|
|
ZeroMemory(ctHelper);
|
|
ZeroMemory(caHelper);
|
|
ZeroMemory(ocsHelper);
|
|
ZeroMemory(x3maHelper);
|
|
|
|
//
|
|
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);
|
|
ZeroMemory(x3maHelper);
|
|
|
|
//
|
|
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 Get3MAConditions(
|
|
X121X3MAConditions &conditions, //
|
|
int barIndex = 0, //
|
|
int loopback = 5 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
result = x3maHelper.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 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();
|
|
x3maHelper.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();
|
|
|
|
//
|
|
// Filling Bars ...
|
|
int barsCount = GetBars(
|
|
conditions.bars,
|
|
mSymbol,
|
|
mPeriod,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
result = barsCount == loopback;
|
|
if (!result)
|
|
{
|
|
//
|
|
conditions.Clean();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Reading Bars Conditions ...
|
|
XOHCL iBar;
|
|
ENUM_X_DIRECTION iDir = X_DIRECTION_NONE;
|
|
for (int i = 0; i < ArraySize(conditions.bars); i++)
|
|
{
|
|
//
|
|
iBar = conditions.bars[i];
|
|
|
|
//
|
|
// Reading Bars Patterns ...
|
|
|
|
//
|
|
// Rejection ...
|
|
bool isRejected =
|
|
barAnalyser
|
|
.IsRejected(
|
|
iBar,
|
|
iDir,
|
|
false,
|
|
true //
|
|
);
|
|
bool isBullishRejected =
|
|
isRejected &&
|
|
IsBullish(iDir);
|
|
bool isBearishRejected =
|
|
isRejected &&
|
|
IsBearish(iDir);
|
|
|
|
//
|
|
Add(
|
|
isBullishRejected,
|
|
conditions.bullishRejectedBars //
|
|
);
|
|
|
|
//
|
|
Add(
|
|
isBearishRejected,
|
|
conditions.bearishRejectedBars //
|
|
);
|
|
|
|
//
|
|
// Engulfing ...
|
|
bool isEngulfed =
|
|
barAnalyser
|
|
.IsEngulfed(
|
|
iBar,
|
|
iDir //
|
|
);
|
|
bool isBullishEngulfed =
|
|
isEngulfed &&
|
|
IsBullish(iDir);
|
|
bool isBearishEngulfed =
|
|
isEngulfed &&
|
|
IsBearish(iDir);
|
|
|
|
//
|
|
Add(
|
|
isBullishEngulfed,
|
|
conditions.bullishEngulfedBars //
|
|
);
|
|
|
|
//
|
|
Add(
|
|
isBearishEngulfed,
|
|
conditions.bearishEngulfedBars //
|
|
);
|
|
|
|
//
|
|
// Momentum ...
|
|
bool isMomentum =
|
|
barAnalyser
|
|
.IsMomentum(
|
|
iBar,
|
|
iDir,
|
|
1 //
|
|
);
|
|
bool isBullishMomentum =
|
|
isMomentum &&
|
|
IsBullish(iDir);
|
|
bool isBearishMomentum =
|
|
isMomentum &&
|
|
IsBearish(iDir);
|
|
|
|
//
|
|
iBar.Clean();
|
|
}
|
|
iBar.Clean();
|
|
|
|
//
|
|
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;
|
|
X121X3MAConditions x3maConditions;
|
|
|
|
//
|
|
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 - 1);
|
|
|
|
//
|
|
// Conditions Retriever ...
|
|
|
|
//
|
|
// XCA ...
|
|
result =
|
|
result &&
|
|
GetCAConditions(
|
|
xcaConditions,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
|
|
//
|
|
// XOSCS ...
|
|
result =
|
|
result &&
|
|
GetOSCSConditions(
|
|
xocsConditions,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
|
|
//
|
|
// X3MA ...
|
|
result =
|
|
result &&
|
|
Get3MAConditions(
|
|
x3maConditions,
|
|
barIndex,
|
|
loopback //
|
|
);
|
|
|
|
//
|
|
// Check Result ...
|
|
if (!result)
|
|
{
|
|
//
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
fromBar.Clean();
|
|
|
|
//
|
|
xcaConditions.Clean();
|
|
xocsConditions.Clean();
|
|
x3maConditions.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;
|
|
|
|
//
|
|
// X3MA ...
|
|
|
|
//
|
|
// Buffers ...
|
|
|
|
//
|
|
Copy(
|
|
x3maConditions.fastBuffer,
|
|
conditions.fastBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
x3maConditions.mediumBuffer,
|
|
conditions.mediumBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
x3maConditions.slowBuffer,
|
|
conditions.slowBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
x3maConditions.fastStateBuffer,
|
|
conditions.fastStateBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
x3maConditions.mediumStateBuffer,
|
|
conditions.mediumStateBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
x3maConditions.slowStateBuffer,
|
|
conditions.slowStateBuffer //
|
|
);
|
|
|
|
//
|
|
// Conditions ...
|
|
|
|
//
|
|
conditions.is3MaBullish = x3maConditions.is3MaBullish;
|
|
conditions.is3MaBearish = x3maConditions.is3MaBearish;
|
|
conditions.isFastOverSlow = x3maConditions.isFastOverSlow;
|
|
conditions.isFastUnderSlow = x3maConditions.isFastUnderSlow;
|
|
conditions.isFastOverMedium = x3maConditions.isFastOverMedium;
|
|
conditions.isMediumOverSlow = x3maConditions.isMediumOverSlow;
|
|
conditions.isFastUnderMedium = x3maConditions.isFastUnderMedium;
|
|
conditions.isMediumUnderSlow = x3maConditions.isMediumUnderSlow;
|
|
conditions.is3MaBullishState = x3maConditions.is3MaBullishState;
|
|
conditions.is3MaBearishState = x3maConditions.is3MaBearishState;
|
|
conditions.is3MaBullishOrdered = x3maConditions.is3MaBullishOrdered;
|
|
conditions.is3MaBearishOrdered = x3maConditions.is3MaBearishOrdered;
|
|
conditions.isFastCrossedOverSlow = x3maConditions.isFastCrossedOverSlow;
|
|
conditions.is3MaSwitchedToBullish = x3maConditions.is3MaSwitchedToBullish;
|
|
conditions.is3MaSwitchedToBearish = x3maConditions.is3MaSwitchedToBearish;
|
|
conditions.isFastCrossedUnderSlow = x3maConditions.isFastCrossedUnderSlow;
|
|
conditions.isFastCrossedOverMedium = x3maConditions.isFastCrossedOverMedium;
|
|
conditions.isMediumCrossedOverSlow = x3maConditions.isMediumCrossedOverSlow;
|
|
conditions.is3MaFinishedFromBullish = x3maConditions.is3MaFinishedFromBullish;
|
|
conditions.is3MaFinishedFromBearish = x3maConditions.is3MaFinishedFromBearish;
|
|
conditions.isFastCrossedUnderMedium = x3maConditions.isFastCrossedUnderMedium;
|
|
conditions.isMediumCrossedUnderSlow = x3maConditions.isMediumCrossedUnderSlow;
|
|
conditions.is3MaSwitchedToBullishState = x3maConditions.is3MaSwitchedToBullishState;
|
|
conditions.is3MaSwitchedToBearishState = x3maConditions.is3MaSwitchedToBearishState;
|
|
conditions.is3MaSwitchedToBullishOrdered = x3maConditions.is3MaSwitchedToBullishOrdered;
|
|
conditions.is3MaSwitchedToBearishOrdered = x3maConditions.is3MaSwitchedToBearishOrdered;
|
|
|
|
//
|
|
// XCA ...
|
|
|
|
//
|
|
// Buffers ...
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.kiBuffer,
|
|
conditions.kiBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.tkiBuffer,
|
|
conditions.tkiBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.vidyaBuffer,
|
|
conditions.vidyaBuffer //
|
|
);
|
|
|
|
//
|
|
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.mahBuffer,
|
|
conditions.mahBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.malBuffer,
|
|
conditions.malBuffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.macBuffer,
|
|
conditions.macBuffer //
|
|
);
|
|
|
|
//
|
|
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.vidyaStateBuffer,
|
|
conditions.vidyaStateBuffer //
|
|
);
|
|
|
|
//
|
|
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.fiboLevel4Buffer,
|
|
conditions.fiboLevel4Buffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.fiboLevel5Buffer,
|
|
conditions.fiboLevel5Buffer //
|
|
);
|
|
|
|
//
|
|
Copy(
|
|
xcaConditions.trendStateBuffer,
|
|
conditions.trendStateBuffer //
|
|
);
|
|
|
|
//
|
|
// Conditions ...
|
|
|
|
//
|
|
conditions.isOverMah = xcaConditions.isOverMah;
|
|
conditions.isOverMal = xcaConditions.isOverMal;
|
|
conditions.isOverMac = xcaConditions.isOverMac;
|
|
conditions.isUnderMah = xcaConditions.isUnderMah;
|
|
conditions.isUnderMal = xcaConditions.isUnderMal;
|
|
conditions.isUnderMac = xcaConditions.isUnderMac;
|
|
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.isCloseOverMah = xcaConditions.isCloseOverMah;
|
|
conditions.isCloseOverMal = xcaConditions.isCloseOverMal;
|
|
conditions.isCloseOverMac = xcaConditions.isCloseOverMac;
|
|
conditions.isVidyaBullish = xcaConditions.isVidyaBullish;
|
|
conditions.isVidyaBearish = xcaConditions.isVidyaBearish;
|
|
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.isCloseUnderMah = xcaConditions.isCloseUnderMah;
|
|
conditions.isCloseUnderMal = xcaConditions.isCloseUnderMal;
|
|
conditions.isCloseUnderMac = xcaConditions.isCloseUnderMac;
|
|
conditions.isTKIRejectDown = xcaConditions.isTKIRejectDown;
|
|
conditions.isPeakUnderLast = xcaConditions.isPeakUnderLast;
|
|
conditions.isValeUnderLast = xcaConditions.isValeUnderLast;
|
|
conditions.isTrendRejectUp = xcaConditions.isTrendRejectUp;
|
|
conditions.isCrossedOverMah = xcaConditions.isCrossedOverMah;
|
|
conditions.isCrossedOverMal = xcaConditions.isCrossedOverMal;
|
|
conditions.isCrossedOverMac = xcaConditions.isCrossedOverMac;
|
|
conditions.isCrossedUnderMah = xcaConditions.isCrossedUnderMah;
|
|
conditions.isCrossedUnderMal = xcaConditions.isCrossedUnderMal;
|
|
conditions.isCrossedUnderMac = xcaConditions.isCrossedUnderMac;
|
|
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.isMahBullishRejected = xcaConditions.isMahBullishRejected;
|
|
conditions.isMahBearishRejected = xcaConditions.isMahBearishRejected;
|
|
conditions.isMalBullishRejected = xcaConditions.isMalBullishRejected;
|
|
conditions.isMalBearishRejected = xcaConditions.isMalBearishRejected;
|
|
conditions.isMacBullishRejected = xcaConditions.isMacBullishRejected;
|
|
conditions.isMacBearishRejected = xcaConditions.isMacBearishRejected;
|
|
conditions.isLastSupportBreaked = xcaConditions.isLastSupportBreaked;
|
|
conditions.isResistanceSameLast = xcaConditions.isResistanceSameLast;
|
|
conditions.isResistanceOverLast = xcaConditions.isResistanceOverLast;
|
|
conditions.isSwingHighUnderLast = xcaConditions.isSwingHighUnderLast;
|
|
conditions.isSwingLowSameAsVale = xcaConditions.isSwingLowSameAsVale;
|
|
conditions.isCloseCrossedOverMah = xcaConditions.isCloseCrossedOverMah;
|
|
conditions.isCloseCrossedOverMal = xcaConditions.isCloseCrossedOverMal;
|
|
conditions.isCloseCrossedOverMac = xcaConditions.isCloseCrossedOverMac;
|
|
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.isPeakSwitchedToPivot = xcaConditions.isPeakSwitchedToPivot;
|
|
conditions.isValeSwitchedToPivot = xcaConditions.isValeSwitchedToPivot;
|
|
conditions.isCloseCrossedUnderMah = xcaConditions.isCloseCrossedUnderMah;
|
|
conditions.isCloseCrossedUnderMal = xcaConditions.isCloseCrossedUnderMal;
|
|
conditions.isCloseCrossedUnderMac = xcaConditions.isCloseCrossedUnderMac;
|
|
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.isPeakFinishedFromPivot = xcaConditions.isPeakFinishedFromPivot;
|
|
conditions.isValeFinishedFromPivot = xcaConditions.isValeFinishedFromPivot;
|
|
conditions.isLastSwingHighRejected = xcaConditions.isLastSwingHighRejected;
|
|
conditions.isLastResistanceBreaked = xcaConditions.isLastResistanceBreaked;
|
|
conditions.isSupportSameAsSwingLow = xcaConditions.isSupportSameAsSwingLow;
|
|
conditions.isKIFinishedFromBullish = xcaConditions.isKIFinishedFromBullish;
|
|
conditions.isKIFinishedFromBearish = xcaConditions.isKIFinishedFromBearish;
|
|
conditions.isTKIFinishedFromBullish = xcaConditions.isTKIFinishedFromBullish;
|
|
conditions.isTKIFinishedFromBearish = xcaConditions.isTKIFinishedFromBearish;
|
|
conditions.isSarFinishedFromBullish = xcaConditions.isSarFinishedFromBullish;
|
|
conditions.isSarFinishedFromBearish = xcaConditions.isSarFinishedFromBearish;
|
|
conditions.isVidyaSwitchedToBullish = xcaConditions.isVidyaSwitchedToBullish;
|
|
conditions.isVidyaSwitchedToBearish = xcaConditions.isVidyaSwitchedToBearish;
|
|
conditions.isLastResistanceRejected = xcaConditions.isLastResistanceRejected;
|
|
conditions.isTrendSwitchedToBullish = xcaConditions.isTrendSwitchedToBullish;
|
|
conditions.isTrendSwitchedToBearish = xcaConditions.isTrendSwitchedToBearish;
|
|
conditions.isVidyaFinishedFromBullish = xcaConditions.isVidyaFinishedFromBullish;
|
|
conditions.isVidyaFinishedFromBearish = xcaConditions.isVidyaFinishedFromBearish;
|
|
conditions.isTrendFinishedFromBullish = xcaConditions.isTrendFinishedFromBullish;
|
|
conditions.isTrendFinishedFromBearish = xcaConditions.isTrendFinishedFromBearish;
|
|
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 //
|
|
);
|
|
|
|
//
|
|
// Values ...
|
|
|
|
//
|
|
conditions.adxThreshold = xocsConditions.adxThreshold;
|
|
conditions.cciOBLevel = xocsConditions.cciOBLevel;
|
|
conditions.cciOSLevel = xocsConditions.cciOSLevel;
|
|
conditions.cciReversalLevel = xocsConditions.cciReversalLevel;
|
|
conditions.rsiOBLevel = xocsConditions.rsiOBLevel;
|
|
conditions.rsiOSLevel = xocsConditions.rsiOSLevel;
|
|
conditions.rsiReversalLevel = xocsConditions.rsiReversalLevel;
|
|
conditions.mfiOBLevel = xocsConditions.mfiOBLevel;
|
|
conditions.mfiOSLevel = xocsConditions.mfiOSLevel;
|
|
conditions.mfiReversalLevel = xocsConditions.mfiReversalLevel;
|
|
conditions.rviBullishLevel = xocsConditions.rviBullishLevel;
|
|
conditions.rviBearishLevel = xocsConditions.rviBearishLevel;
|
|
conditions.macdBullishLevel = xocsConditions.macdBullishLevel;
|
|
conditions.macdBearishLevel = xocsConditions.macdBearishLevel;
|
|
conditions.momentumBullishLevel = xocsConditions.momentumBullishLevel;
|
|
conditions.momentumBearishLevel = xocsConditions.momentumBearishLevel;
|
|
conditions.stochasticOBLevel = xocsConditions.stochasticOBLevel;
|
|
conditions.stochasticOSLevel = xocsConditions.stochasticOSLevel;
|
|
conditions.stochasticReversalLevel = xocsConditions.stochasticReversalLevel;
|
|
|
|
//
|
|
// 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;
|
|
|
|
//
|
|
int bodiesCount = barAnalyser.GetPriceRange(
|
|
conditions.bodies,
|
|
zBar,
|
|
true, // Force Body ...
|
|
true, // Force Price Diff ...
|
|
loopback //
|
|
);
|
|
int rangesCount = barAnalyser.GetPriceRange(
|
|
conditions.ranges,
|
|
zBar,
|
|
true, // Force Body ...
|
|
true, // Force Price Diff ...
|
|
loopback //
|
|
);
|
|
|
|
//
|
|
int velocitiesCount =
|
|
barAnalyser
|
|
.GetPriceVelocity(
|
|
conditions.velocities,
|
|
zBar,
|
|
X_PRICE_CLOSE,
|
|
loopback //
|
|
);
|
|
|
|
//
|
|
double bullishVolume = 0.0;
|
|
double bearishVolume = 0.0;
|
|
barAnalyser
|
|
.CalculateRangeVolume(
|
|
zBar,
|
|
bullishVolume,
|
|
bearishVolume,
|
|
loopback //
|
|
);
|
|
conditions.scoreBullish = bullishVolume;
|
|
conditions.scoreBearish = bearishVolume;
|
|
|
|
//
|
|
double bullishScore = 0.0;
|
|
double bearishScore = 0.0;
|
|
conditions.GenerateScore(
|
|
bullishScore,
|
|
bearishScore //
|
|
);
|
|
conditions.volumeBullish = bullishScore;
|
|
conditions.volumeBearish = bearishScore;
|
|
|
|
//
|
|
double priceChangeRate =
|
|
barAnalyser
|
|
.GetPriceChangeRate(
|
|
zBar,
|
|
X_PRICE_CLOSE,
|
|
loopback //
|
|
);
|
|
conditions.priceChangeRate = priceChangeRate;
|
|
|
|
//
|
|
// Cleanup Resource ...
|
|
|
|
//
|
|
zBar.Clean();
|
|
cBar.Clean();
|
|
pBar.Clean();
|
|
fromBar.Clean();
|
|
|
|
//
|
|
xcaConditions.Clean();
|
|
xocsConditions.Clean();
|
|
x3maConditions.Clean();
|
|
|
|
//
|
|
Free();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bool IsBlockBasedTriggerBar(
|
|
XBoxZone &ob,
|
|
XOHCL &swingBar,
|
|
XOHCL &breakerBar,
|
|
XOHCL &outSideBar,
|
|
ENUM_X_DIRECTION &dir,
|
|
int barIndex = 0,
|
|
int loopback = 40,
|
|
int swingLength = 3 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Normalize Args ...
|
|
ob.Clean();
|
|
swingBar.Clean();
|
|
breakerBar.Clean();
|
|
outSideBar.Clean();
|
|
dir = X_DIRECTION_NONE;
|
|
barIndex = NormalizeInt(barIndex, 0);
|
|
loopback = NormalizeInt(loopback, 30);
|
|
|
|
//
|
|
// Initializing Current Bar ...
|
|
XOHCL bar;
|
|
result = bar.Init(
|
|
GetSymbol(),
|
|
GetPeriod(),
|
|
barIndex //
|
|
);
|
|
if (!result)
|
|
{
|
|
//
|
|
ob.Clean();
|
|
bar.Clean();
|
|
swingBar.Clean();
|
|
breakerBar.Clean();
|
|
outSideBar.Clean();
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Detecting Newest Block ...
|
|
XOHCL iBar;
|
|
bool has = false;
|
|
for (int i = barIndex; i < barIndex + loopback; i++)
|
|
{
|
|
//
|
|
// Initialize iBar ...
|
|
has = iBar.Init(
|
|
bar.symbol,
|
|
bar.period,
|
|
i //
|
|
);
|
|
if (!has)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Check to Find OB ...
|
|
has = barAnalyser.IsOB(
|
|
iBar,
|
|
ob,
|
|
false,
|
|
true //
|
|
);
|
|
if (has)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
|
|
//
|
|
break;
|
|
}
|
|
|
|
//
|
|
ob.Clean();
|
|
iBar.Clean();
|
|
}
|
|
|
|
//
|
|
// Ensure We Have a Block ...
|
|
result = ob.IsValid();
|
|
if (!result)
|
|
{
|
|
//
|
|
ob.Clean();
|
|
bar.Clean();
|
|
iBar.Clean();
|
|
swingBar.Clean();
|
|
breakerBar.Clean();
|
|
outSideBar.Clean();
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Set Direction ...
|
|
dir = ob.dir;
|
|
int toIDX = ob.ToIndex();
|
|
int fromIDX = ob.FromIndex();
|
|
bool isBullish = IsBullish(dir);
|
|
bool isBearish = IsBearish(dir);
|
|
|
|
//
|
|
// Ensure a Swing Breaked in Block Formation ...
|
|
// for Bullish we have to Breake a Swing High ...
|
|
// for Bearish we have to Detect a Swing Low ...
|
|
// this Breaktion must appear after Block ...
|
|
ENUM_X_DIRECTION swingDir = X_DIRECTION_NONE;
|
|
for (int i = barIndex + loopback; i > barIndex; i--)
|
|
{
|
|
//
|
|
// Initialize iBar ...
|
|
has = iBar.Init(
|
|
bar.symbol,
|
|
bar.period,
|
|
i //
|
|
);
|
|
if (!has)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
swingBar.Clean();
|
|
swingDir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Detecting Swing ...
|
|
has = barAnalyser.IsSwing(
|
|
iBar,
|
|
swingDir //
|
|
);
|
|
has =
|
|
has &&
|
|
iBar.GetPreviousBar(swingBar);
|
|
if (!has)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
swingBar.Clean();
|
|
swingDir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Validate Founded Swing ...
|
|
|
|
//
|
|
bool isValidSwingLow =
|
|
isBearish &&
|
|
IsBullish(swingDir);
|
|
|
|
//
|
|
bool isValidSwingHigh =
|
|
isBullish &&
|
|
IsBearish(swingDir);
|
|
|
|
//
|
|
has =
|
|
isValidSwingLow ||
|
|
isValidSwingHigh;
|
|
if (!has)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
swingBar.Clean();
|
|
swingDir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Validating Swing Place ...
|
|
|
|
//
|
|
bool isSwingLowHasValidPlace =
|
|
isBearish &&
|
|
swingBar.low < ob.lower;
|
|
|
|
//
|
|
bool isSwingHighHasValidPlace =
|
|
isBullish &&
|
|
swingBar.high > ob.upper;
|
|
|
|
//
|
|
has =
|
|
isSwingLowHasValidPlace ||
|
|
isSwingHighHasValidPlace;
|
|
if (has)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
|
|
//
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBar.Clean();
|
|
swingBar.Clean();
|
|
swingDir = X_DIRECTION_NONE;
|
|
}
|
|
|
|
//
|
|
result =
|
|
swingBar.IsValid() &&
|
|
HasDirection(swingDir);
|
|
if (!result)
|
|
{
|
|
//
|
|
ob.Clean();
|
|
bar.Clean();
|
|
iBar.Clean();
|
|
swingBar.Clean();
|
|
breakerBar.Clean();
|
|
outSideBar.Clean();
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// now We have Proper Swing ...
|
|
// Validate Swing Breaktion ...
|
|
double breakPrice =
|
|
IsBullish(swingDir)
|
|
? swingBar.low
|
|
: swingBar.high;
|
|
ENUM_X_DIRECTION breakedDir =
|
|
IsBullish(swingDir)
|
|
? X_DIRECTION_BEARISH
|
|
: X_DIRECTION_BULLISH;
|
|
for (int i = swingBar.Index(); i > barIndex; i--)
|
|
{
|
|
//
|
|
// Initialize iBar ...
|
|
has = iBar.Init(
|
|
bar.symbol,
|
|
bar.period,
|
|
i //
|
|
);
|
|
if (!has)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
breakerBar.Clean();
|
|
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Check for Breakes ...
|
|
has = iBar.IsBreaked(
|
|
breakPrice,
|
|
breakedDir //
|
|
);
|
|
if (!has)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
breakerBar.Clean();
|
|
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Validate Swing Break must be happens
|
|
// after Block Formation ...
|
|
has = iBar.time > ob.to;
|
|
if (has)
|
|
{
|
|
//
|
|
breakerBar = iBar;
|
|
|
|
//
|
|
iBar.Clean();
|
|
|
|
//
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBar.Clean();
|
|
breakerBar.Clean();
|
|
}
|
|
|
|
//
|
|
result = breakerBar.IsValid();
|
|
if (!result)
|
|
{
|
|
//
|
|
ob.Clean();
|
|
bar.Clean();
|
|
iBar.Clean();
|
|
swingBar.Clean();
|
|
breakerBar.Clean();
|
|
outSideBar.Clean();
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// now we have a Valid Bloc ...
|
|
// which Breakes a Valid Swing ...
|
|
|
|
//
|
|
// find at least on out side of Block Bar ...
|
|
for (int i = toIDX; i > barIndex; i--)
|
|
{
|
|
//
|
|
// Initialize iBar ...
|
|
has = iBar.Init(
|
|
bar.symbol,
|
|
bar.period,
|
|
i //
|
|
);
|
|
if (!has)
|
|
{
|
|
//
|
|
iBar.Clean();
|
|
outSideBar.Clean();
|
|
|
|
//
|
|
continue;
|
|
}
|
|
|
|
//
|
|
bool isBullishOutside =
|
|
isBullish &&
|
|
iBar.high > ob.upper;
|
|
|
|
//
|
|
bool isBearishOutside =
|
|
isBearish &&
|
|
iBar.low < ob.lower;
|
|
|
|
//
|
|
has =
|
|
isBullishOutside ||
|
|
isBearishOutside;
|
|
if (has)
|
|
{
|
|
//
|
|
outSideBar = iBar;
|
|
|
|
//
|
|
iBar.Clean();
|
|
|
|
//
|
|
break;
|
|
}
|
|
|
|
//
|
|
iBar.Clean();
|
|
outSideBar.Clean();
|
|
}
|
|
|
|
//
|
|
result = outSideBar.IsValid();
|
|
if (!result)
|
|
{
|
|
//
|
|
ob.Clean();
|
|
bar.Clean();
|
|
iBar.Clean();
|
|
swingBar.Clean();
|
|
breakerBar.Clean();
|
|
outSideBar.Clean();
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// we Are Looking for Bar inside Block ...
|
|
|
|
//
|
|
bool isBullishInside =
|
|
isBullish &&
|
|
bar.low < ob.upper &&
|
|
bar.low > ob.lower;
|
|
|
|
//
|
|
bool isBearishInside =
|
|
isBearish &&
|
|
bar.high > ob.lower &&
|
|
bar.high < ob.upper;
|
|
|
|
//
|
|
result = isBullishInside ||
|
|
isBearishInside;
|
|
if (!result)
|
|
{
|
|
//
|
|
ob.Clean();
|
|
bar.Clean();
|
|
iBar.Clean();
|
|
swingBar.Clean();
|
|
breakerBar.Clean();
|
|
outSideBar.Clean();
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Since we Ensure have an Inside Block Bar here ...
|
|
// must to detect a Bar Pattern verification for Triggering ...
|
|
|
|
//
|
|
// Check Bar Pattern for Position ...
|
|
ENUM_X_DIRECTION patternDir;
|
|
|
|
//
|
|
// Hammer ...
|
|
bool isHammer = barAnalyser.IsHammer(
|
|
bar,
|
|
patternDir //
|
|
);
|
|
bool isBullishHammer =
|
|
isHammer &&
|
|
IsBullish(patternDir);
|
|
bool isBearishHammer =
|
|
isHammer &&
|
|
IsBearish(patternDir);
|
|
|
|
//
|
|
// Reject ...
|
|
bool isReject = barAnalyser.IsRejected(
|
|
bar,
|
|
patternDir,
|
|
false, // Force Bar type ...
|
|
true // Force Fibo Pressure ...
|
|
);
|
|
bool isBullishReject =
|
|
isReject &&
|
|
IsBullish(patternDir);
|
|
bool isBearishReject =
|
|
isReject &&
|
|
IsBearish(patternDir);
|
|
|
|
//
|
|
// Engulf ...
|
|
bool isEngulf = barAnalyser.IsEngulfed(
|
|
bar,
|
|
patternDir //
|
|
);
|
|
bool isBullishEngulf =
|
|
isEngulf &&
|
|
IsBullish(patternDir);
|
|
bool isBearishEngulf =
|
|
isEngulf &&
|
|
IsBearish(patternDir);
|
|
|
|
//
|
|
bool isBarBullishPowered =
|
|
isBullishHammer ||
|
|
isBullishReject ||
|
|
isBullishEngulf;
|
|
|
|
//
|
|
bool isBarBearishPowered =
|
|
isBearishHammer ||
|
|
isBearishReject ||
|
|
isBearishEngulf;
|
|
|
|
//
|
|
// Summarizing Result ...
|
|
|
|
//
|
|
bool isBullishTriggered =
|
|
isBullish &&
|
|
isBullishInside &&
|
|
isBarBullishPowered;
|
|
|
|
//
|
|
bool isBearishTriggered =
|
|
isBearish &&
|
|
isBearishInside &&
|
|
isBarBearishPowered;
|
|
|
|
//
|
|
result = isBullishTriggered ||
|
|
isBearishTriggered;
|
|
|
|
//
|
|
if (!result)
|
|
{
|
|
//
|
|
ob.Clean();
|
|
bar.Clean();
|
|
iBar.Clean();
|
|
swingBar.Clean();
|
|
breakerBar.Clean();
|
|
outSideBar.Clean();
|
|
dir = X_DIRECTION_NONE;
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
bar.Clean();
|
|
|
|
//
|
|
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;
|
|
};
|
|
|
|
// |