From 41c5feb9faffb86d7f5f8380d70932bf476806a3 Mon Sep 17 00:00:00 2001 From: Hadi Khazaee Asl Date: Thu, 8 Feb 2024 16:17:48 +0330 Subject: [PATCH] resolve all guards on Alpari --- ...-saherelm.xau5.provider.indicators.lib.mq5 | 43 +- ...relm.xau5.provider.indicators.lib_@!!@.mq5 | 12404 ++++++++++++++++ ...-saherelm.xau5.provider.indicators.lib.mq5 | 43 +- ...-saherelm.xau5.provider.indicators.lib.mq5 | 43 +- 4 files changed, 12494 insertions(+), 39 deletions(-) create mode 100644 BKP/Main/Providers/x-saherelm.xau5.provider.indicators.lib_@!!@.mq5 diff --git a/BKP/Main/Providers/x-saherelm.xau5.provider.indicators.lib.mq5 b/BKP/Main/Providers/x-saherelm.xau5.provider.indicators.lib.mq5 index 775d6e71..ff0fafb0 100644 --- a/BKP/Main/Providers/x-saherelm.xau5.provider.indicators.lib.mq5 +++ b/BKP/Main/Providers/x-saherelm.xau5.provider.indicators.lib.mq5 @@ -7165,6 +7165,13 @@ bool XAU5XTSFIHasShortSignal() mConditions.isXAMABearish && mConditions.isXTSCurrentOverMediest) && ( + // + (mConditions.isXTDBullUnderBear && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMAMCFastUnderSlow) + // + || // (mConditions.isXCHMALCVale && mConditions.isXCHLHMCLCLLSame && @@ -7651,19 +7658,19 @@ bool XAU5XTSFIHasShortSignal() ( // ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) + mConditions.isXAMANeutural) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) // ) // @@ -10612,6 +10619,16 @@ bool XAU5XCHMAMNHasLongSignal() mConditions.isXTSCurrentCrossedOverNearest && mConditions.isXTSCurrentCrossedOverMediest) // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXLHLLIncreased && + mConditions.isXTMStartBullish && + mConditions.isXAMAStartBullish && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentCrossedOverFarest) + // ) // ) diff --git a/BKP/Main/Providers/x-saherelm.xau5.provider.indicators.lib_@!!@.mq5 b/BKP/Main/Providers/x-saherelm.xau5.provider.indicators.lib_@!!@.mq5 new file mode 100644 index 00000000..ff0fafb0 --- /dev/null +++ b/BKP/Main/Providers/x-saherelm.xau5.provider.indicators.lib_@!!@.mq5 @@ -0,0 +1,12404 @@ +/////////////////////////////////////////////////////////////////// +// +// SaherElm IT Center MQL5 XAU5 Signal Provider Indicators Library +// ---------------------------------------------------------------- +// +// Maintainer: +// ------------ +// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) +// +////////////////////////////////////////////////////// +// +// Global Properties ... +#property library +#property copyright "Copyright 2023, SaherElm IT Center" +#property link "https://www.saherelm.ir" +#property version "1.00" +#property strict + +// +// Include Provider Inputs ... +#include "x-saherelm.xau5.provider.inputs.lib.mq5" + +// +// Include Provider Class ... +#include "../Classes/x-saherelm.provider.lib.mq5" + +// +// Signallers ... +input group "XAU5 Signallers"; + +// +// XTD ... +input group "XAU5 XTD Signaller"; +input bool xAU5XTDEnableSignaller = true; // Enable Signaller +input bool xAU5XTDAllowLongSignals = true; // Enable Long Signals +input bool xAU5XTDAllowShortSignals = true; // Enable Short Signals + +// +// XTAM ... +input group "XAU5 XTAM Signaller"; +input bool xAU5XTAMEnableSignaller = true; // Enable Signaller +input bool xAU5XTAMAllowLongSignals = true; // Enable Long Signals +input bool xAU5XTAMAllowShortSignals = true; // Enable Short Signals + +// +// XSI ... +input group "XAU5 XSI Signaller"; +input bool xAU5XSIEnableSignaller = true; // Enable Signaller +input bool xAU5XSIAllowLongSignals = true; // Enable Long Signals +input bool xAU5XSIAllowShortSignals = true; // Enable Short Signals + +// +// XTSFI ... +input group "XAU5 XTSFI Signaller"; +input bool xAU5XTSFIEnableSignaller = true; // Enable Signaller +input bool xAU5XTSFIAllowLongSignals = true; // Enable Long Signals +input bool xAU5XTSFIAllowShortSignals = true; // Enable Short Signals + +// +// XOBDLH ... +input group "XAU5 XOBDLH Signaller"; +input bool xAU5XOBDLHEnableSignaller = true; // Enable Signaller +input bool xAU5XOBDLHAllowLongSignals = true; // Enable Long Signals +input bool xAU5XOBDLHAllowShortSignals = true; // Enable Short Signals + +// +// XCHMACC ... +input group "XAU5 XCHMACC Signaller"; +input bool xAU5XCHMACCEnableSignaller = true; // Enable Signaller +input bool xAU5XCHMACCAllowLongSignals = true; // Enable Long Signals +input bool xAU5XCHMACCAllowShortSignals = true; // Enable Short Signals + +// +// XCHMAMX ... +input group "XAU5 XCHMAMX Signaller"; +input bool xAU5XCHMAMXEnableSignaller = true; // Enable Signaller +input bool xAU5XCHMAMXAllowLongSignals = true; // Enable Long Signals +input bool xAU5XCHMAMXAllowShortSignals = true; // Enable Short Signals + +// +// XCHMAMN ... +input group "XAU5 XCHMAMN Signaller"; +input bool xAU5XCHMAMNEnableSignaller = true; // Enable Signaller +input bool xAU5XCHMAMNAllowLongSignals = true; // Enable Long Signals +input bool xAU5XCHMAMNAllowShortSignals = true; // Enable Short Signals + +// +// Check in Test Mode or not ... +bool xAU5IsTestMode = false; + +// +// Detect max Input Length of Indicators ... +int xAU5MaxLengthOfInputs = 0; + +// +// Detect Calculated Bars ... +int xAU5CalculatedBars = 0; + +// +// Check prevent Double Signalling on Same Candle ... +bool xAU5WaitUntilNextCandle = false; + +// +// Signaller Variables ... +// +// XTD ... +bool xAU5MXTDEnableSignaller = xAU5XTDEnableSignaller; +bool xAU5MXTDAllowLongSignals = xAU5XTDAllowLongSignals; +bool xAU5MXTDAllowShortSignals = xAU5XTDAllowShortSignals; + +// +// XTAM ... +bool xAU5MXTAMEnableSignaller = xAU5XTAMEnableSignaller; +bool xAU5MXTAMAllowLongSignals = xAU5XTAMAllowLongSignals; +bool xAU5MXTAMAllowShortSignals = xAU5XTAMAllowShortSignals; + +// +// XSI ... +bool xAU5MXSIEnableSignaller = xAU5XSIEnableSignaller; +bool xAU5MXSIAllowLongSignals = xAU5XSIAllowLongSignals; +bool xAU5MXSIAllowShortSignals = xAU5XSIAllowShortSignals; + +// +// XTSFI ... +bool xAU5MXTSFIEnableSignaller = xAU5XTSFIEnableSignaller; +bool xAU5MXTSFIAllowLongSignals = xAU5XTSFIAllowLongSignals; +bool xAU5MXTSFIAllowShortSignals = xAU5XTSFIAllowShortSignals; + +// +// XOBDLH ... +bool xAU5MXOBDLHEnableSignaller = xAU5XOBDLHEnableSignaller; +bool xAU5MXOBDLHAllowLongSignals = xAU5XOBDLHAllowLongSignals; +bool xAU5MXOBDLHAllowShortSignals = xAU5XOBDLHAllowShortSignals; + +// +// XCHMACC ... +bool xAU5MXCHMACCEnableSignaller = xAU5XCHMACCEnableSignaller; +bool xAU5MXCHMACCAllowLongSignals = xAU5XCHMACCAllowLongSignals; +bool xAU5MXCHMACCAllowShortSignals = xAU5XCHMACCAllowShortSignals; + +// +// XCHMAMX ... +bool xAU5MXCHMAMXEnableSignaller = xAU5XCHMAMXEnableSignaller; +bool xAU5MXCHMAMXAllowLongSignals = xAU5XCHMAMXAllowLongSignals; +bool xAU5MXCHMAMXAllowShortSignals = xAU5XCHMAMXAllowShortSignals; + +// +// XCHMAMN ... +bool xAU5MXCHMAMNEnableSignaller = xAU5XCHMAMNEnableSignaller; +bool xAU5MXCHMAMNAllowLongSignals = xAU5XCHMAMNAllowLongSignals; +bool xAU5MXCHMAMNAllowShortSignals = xAU5XCHMAMNAllowShortSignals; + +// +XCPriver *xAU5Provider; + +// +// Validate Indicators Inputs ... +bool XAU5ValidateIndicatorsInputs() +{ + // + bool result = false; + + // + // XTM ... + result = XTMValidateInputs(); + if (!result) + { + return result; + } + + // + // XAMA ... + result = XAMAValidateInputs(); + if (!result) + { + return result; + } + + // + // XTD ... + result = XTDValidateInputs(); + if (!result) + { + return result; + } + + // + // XFI ... + result = XFIValidateInputs(); + if (!result) + { + return result; + } + + // + // XTS ... + result = XTSValidateInputs(); + if (!result) + { + return result; + } + + // + // XOBD ... + result = XOBDValidateInputs(); + if (!result) + { + return result; + } + + // + // XLH ... + result = XLHValidateInputs(); + if (!result) + { + return result; + } + + // + // XRSI ... + result = XRSIValidateInputs(); + if (!result) + { + return result; + } + + // + // XCHLH ... + result = XCHLHValidateInputs(); + if (!result) + { + return result; + } + + // + // XCHMA ... + result = XCHMAValidateInputs(); + if (!result) + { + return result; + } + + // + // Make an Instance Of XCPriver Class for Use ... + xAU5Provider = new XCPriver( + // + // Commons ... + _Symbol, + _Period, + // + // Signallers ... + // + // XTD ... + xAU5MXTDEnableSignaller, + xAU5MXTDAllowLongSignals, + xAU5MXTDAllowShortSignals, + // + // XTAM ... + xAU5MXTAMEnableSignaller, + xAU5MXTAMAllowLongSignals, + xAU5MXTAMAllowShortSignals, + // + // XSI ... + xAU5MXSIEnableSignaller, + xAU5MXSIAllowLongSignals, + xAU5MXSIAllowShortSignals, + // + // XTSFI ... + xAU5MXTSFIEnableSignaller, + xAU5MXTSFIAllowLongSignals, + xAU5MXTSFIAllowShortSignals, + // + // XOBDLH ... + xAU5MXOBDLHEnableSignaller, + xAU5MXOBDLHAllowLongSignals, + xAU5MXOBDLHAllowShortSignals, + // + // XCHMACC ... + xAU5MXCHMACCEnableSignaller, + xAU5MXCHMACCAllowLongSignals, + xAU5MXCHMACCAllowShortSignals, + // + // XCHMAMX ... + xAU5MXCHMAMXEnableSignaller, + xAU5MXCHMAMXAllowLongSignals, + xAU5MXCHMAMXAllowShortSignals, + // + // XCHMAMN ... + xAU5MXCHMAMNEnableSignaller, + xAU5MXCHMAMNAllowLongSignals, + xAU5MXCHMAMNAllowShortSignals + // + ); + + // + result = true; + + // + return result; +} + +// +// Init Indicators ... +bool XAU5InitIndicators() +{ + // + bool result = false; + + // + // Make it Enable when we need to Log Market Conditions ... + xAU5IsTestMode = IsRunningOnTestMode(); + + // + // Check and Calculate Max Length in Inputs ... + // + + // + // XTM ... + xAU5MaxLengthOfInputs = MathMax( + xTMMaPeriod, + xAU5NumberOfItemsPerTick); + + // + // XAMA ... + xAU5MaxLengthOfInputs = MathMax( + xAMALength, + xAU5NumberOfItemsPerTick); + xAU5MaxLengthOfInputs = MathMax( + xAMAFastEMA, + xAU5NumberOfItemsPerTick); + xAU5MaxLengthOfInputs = MathMax( + xAMASlowEMA, + xAU5NumberOfItemsPerTick); + + // + // XLH ... + xAU5MaxLengthOfInputs = MathMax( + xLHLength, + xAU5NumberOfItemsPerTick); + + // + // XTD ... + xAU5MaxLengthOfInputs = MathMax( + xTDLength, + xAU5MaxLengthOfInputs); + + // + // XFI ... + xAU5MaxLengthOfInputs = MathMax( + xFILength, + xAU5MaxLengthOfInputs); + + // + // XRSI ... + xAU5MaxLengthOfInputs = MathMax( + xRSILength, + xAU5MaxLengthOfInputs); + + // + // XOBD ... + xAU5MaxLengthOfInputs = MathMax( + xOBDLength, + xAU5MaxLengthOfInputs); + + // + // XCHLH ... + xAU5MaxLengthOfInputs = MathMax( + xCHLHLcLength, + xAU5MaxLengthOfInputs); + xAU5MaxLengthOfInputs = MathMax( + xCHLHMcLength, + xAU5MaxLengthOfInputs); + xAU5MaxLengthOfInputs = MathMax( + xCHLHScLength, + xAU5MaxLengthOfInputs); + + // + // XCHMA ... + xAU5MaxLengthOfInputs = MathMax( + xCHMAScFastLength, + xAU5MaxLengthOfInputs); + xAU5MaxLengthOfInputs = MathMax( + xCHMAScSlowLength, + xAU5MaxLengthOfInputs); + xAU5MaxLengthOfInputs = MathMax( + xCHMAMcFastLength, + xAU5MaxLengthOfInputs); + xAU5MaxLengthOfInputs = MathMax( + xCHMAMcSlowLength, + xAU5MaxLengthOfInputs); + xAU5MaxLengthOfInputs = MathMax( + xCHMALcFastLength, + xAU5MaxLengthOfInputs); + xAU5MaxLengthOfInputs = MathMax( + xCHMALcSlowLength, + xAU5MaxLengthOfInputs); + + // + // Validate Indicators Inputs before Initialization ... + result = XAU5ValidateIndicatorsInputs(); + if (!result) + { + return result; + } + + // + // Validate Signallers ... + + // + // XTD ... + bool isXTDEnable = + xAU5XTDEnableSignaller && + (xAU5XTDAllowLongSignals || + xAU5XTDAllowShortSignals); + + // + // XTAM ... + bool isXTAMEnable = + xAU5XTAMEnableSignaller && + (xAU5XTAMAllowLongSignals || + xAU5XTAMAllowShortSignals); + + // + // XSI ... + bool isXSIEnable = + xAU5XSIEnableSignaller && + (xAU5XSIAllowLongSignals || + xAU5XSIAllowShortSignals); + + // + // XTSFI ... + bool isXTSFIEnable = + xAU5XTSFIEnableSignaller && + (xAU5XTSFIAllowLongSignals || + xAU5XTSFIAllowShortSignals); + + // + // XOBDLH ... + bool isXOBDLHEnable = + xAU5XOBDLHEnableSignaller && + (xAU5XOBDLHAllowLongSignals || + xAU5XOBDLHAllowShortSignals); + + // + // XCHMACC ... + bool isXCHMACCEnable = + xAU5XCHMACCEnableSignaller && + (xAU5XCHMACCAllowLongSignals || + xAU5XCHMACCAllowShortSignals); + + // + // XCHMAMX ... + bool isXCHMAMXEnable = + xAU5XCHMAMXEnableSignaller && + (xAU5XCHMAMXAllowLongSignals || + xAU5XCHMAMXAllowShortSignals); + + // + // XCHMAMN ... + bool isXCHMAMNEnable = + xAU5XCHMAMNEnableSignaller && + (xAU5XCHMAMNAllowLongSignals || + xAU5XCHMAMNAllowShortSignals); + + // + bool hasSignaller = + // + isXTDEnable || + isXTAMEnable || + isXSIEnable || + isXTSFIEnable || + isXOBDLHEnable || + isXCHMACCEnable || + isXCHMAMXEnable || + isXCHMAMNEnable + // + ; + result = hasSignaller; + if (!result) + { + // + LogMessage("XAU5 doesn't enable any Signaller ..."); + + // + return result; + } + + // + // Initialize Indicator/Oscillator Handlers ... + ResetLastError(); + + // + // XTM Init ... + result = XTMInitHandlers(); + if (!result) + { + return result; + } + + // + // XAMA Init ... + result = XAMAInitHandlers(); + if (!result) + { + return result; + } + + // + // XLH Init ... + result = XLHInitHandlers(); + if (!result) + { + return result; + } + + // + // XTD Init ... + result = XTDInitHandlers(); + if (!result) + { + return result; + } + + // + // XFI Init ... + result = XFIInitHandlers(); + if (!result) + { + return result; + } + + // + // XTS Init ... + result = XTSInitHandlers(); + if (!result) + { + return result; + } + + // + // XRSI Init ... + result = XRSIInitHandlers(); + if (!result) + { + return result; + } + + // + // XOBD Init ... + result = XOBDInitHandlers(); + if (!result) + { + return result; + } + + // + // XCLH Init ... + result = XCHLHInitHandlers(); + if (!result) + { + return result; + } + + // + // XCHMA Init ... + result = XCHMAInitHandlers(); + if (!result) + { + return result; + } + + // + result = true; + + // + return result; +} + +// +// Release Indicators ... +void XAU5ReleaseIndicators() +{ + // + // Release Handlers ... + XTMReleaseHandlers(); + XAMAReleaseHandlers(); + XLHReleaseHandlers(); + XTDReleaseHandlers(); + XFIReleaseHandlers(); + XTSReleaseHandlers(); + XRSIReleaseHandlers(); + XOBDReleaseHandlers(); + XCHMAReleaseHandlers(); + XCHLHReleaseHandlers(); +} + +// +// Handle Reading Buffers ... +void XAU5HandleReadingBuffers() +{ + // + // Reading Calculated Bars for a Simple Handler ... + xAU5CalculatedBars = BarsCalculated(xTMHandler); + + // + // Read Indicators Buffers ... + XTMReadBuffers(xAU5NumberOfItemsPerTick); + XAMAReadBuffers(xAU5NumberOfItemsPerTick); + XLHReadBuffers(xAU5NumberOfItemsPerTick); + XTDReadBuffers(xAU5NumberOfItemsPerTick); + XFIReadBuffers(xAU5NumberOfItemsPerTick); + XTSReadBuffers(xAU5NumberOfItemsPerTick); + XRSIReadBuffers(xAU5NumberOfItemsPerTick); + XOBDReadBuffers(xAU5NumberOfItemsPerTick); + XCHMAReadBuffers(xAU5NumberOfItemsPerTick); + XCHLHReadBuffers(xAU5NumberOfItemsPerTick); + + // + xAU5Provider.ReadConditions(); +} + +// +// +// START Combination Functions ... +// +// + +// +// Can Open Long Trade ... +// this is a Function will Check all market Conditions and get all +// Strategy requirement Verifications for Long Signals ... +bool XAU5CanOpenLongTrade( + XProvidedSignal &info // Retrieve Signal Additional Info on this Object +) +{ + // + bool result = false; + + // + info.tp = 0; + info.sl = 0; + ArrayResize( + info.signallers, + 0); + + // + bool hasSignal = XAU5HasLongSignal(info); + + // + result = + // + hasSignal + // + ; + + // + if (result) + { + xAU5Provider.ClearConditions(); + } + + // + return result; +} + +// +// Can Close Long Trade ... +// this is a Function will Check all market Conditions and get all +// Strategy requirement Verifications for Long Signals ... +bool XAU5CanCloseLongTrade() +{ + // + bool result = false; + + // + return result; +} + +// +// Can Open Short Trade ... +// this is a Function will Check all market Conditions and get all +// Strategy requirement Verifications for Short Signals ... +bool XAU5CanOpenShortTrade( + XProvidedSignal &info // Retrieve Signal Additional Info on this Object +) +{ + // + bool result = false; + + // + info.tp = 0; + info.sl = 0; + ArrayResize( + info.signallers, + 0); + + // + bool hasSignal = XAU5HasShortSignal(info); + + // + result = + // + hasSignal + // + ; + + // + if (result) + { + xAU5Provider.ClearConditions(); + } + + // + return result; +} + +// +// Can Close Short Trade ... +// this is a Function will Check all market Conditions and get all +// Strategy requirement Verifications for Short Signals ... +bool XAU5CanCloseShortTrade() +{ + // + bool result = false; + + // + return result; +} + +// +// +// END Combination Functions ... +// +// + +// +// +// START Combination Signaling ... +// +// + +// +// Check Market Conditions by Combination of Power of All tools for LONGs ... +bool XAU5HasLongSignal( + XProvidedSignal &info // Retrieve Signal Additional Info on this Object +) +{ + // + bool result = false; + + // + // XTD ... + bool isXTDHasSignal = XAU5XTDHasLongSignal(); + if (isXTDHasSignal) + { + // + Add( + EnumToString(XTD), + info.signallers); + } + + // + // XTAM ... + bool isXTAMHasSignal = XAU5XTAMHasLongSignal(); + if (isXTAMHasSignal) + { + // + Add( + EnumToString(XTAM), + info.signallers); + } + + // + // XSI ... + bool isXSIHasSignal = XAU5XSIHasLongSignal(); + if (isXSIHasSignal) + { + // + Add( + EnumToString(XSI), + info.signallers); + } + + // + // XTSFI ... + bool isXTSFIHasSignal = XAU5XTSFIHasLongSignal(); + if (isXTSFIHasSignal) + { + // + Add( + EnumToString(XTSFI), + info.signallers); + } + + // + // XOBD XLH ... + bool isXOBDLHHasSignal = XAU5XOBDLHHasLongSignal(); + if (isXOBDLHHasSignal) + { + // + Add( + EnumToString(XOBDLH), + info.signallers); + } + + // + // XCHMA Cycles Cross ... + bool isXCHMACCHasSignal = XAU5XCHMACCHasLongSignal(); + if (isXCHMACCHasSignal) + { + // + Add( + EnumToString(XCHMACC), + info.signallers); + } + + // + // XCHMA Cycles Min ... + bool isXCHMAMNHasSignal = XAU5XCHMAMNHasLongSignal(); + if (isXCHMAMNHasSignal) + { + // + Add( + EnumToString(XCHMAMN), + info.signallers); + } + + // + // XCHMA Cycles Max + bool isXCHMAMXHasSignal = XAU5XCHMAMXHasLongSignal(); + if (isXCHMAMXHasSignal) + { + // + Add( + EnumToString(XCHMAMX), + info.signallers); + } + + // + result = + // + isXTDHasSignal + // + || + // + isXTAMHasSignal + // + || + // + isXSIHasSignal + // + || + // + isXTSFIHasSignal + // + || + // + isXOBDLHHasSignal + // + || + // + isXCHMACCHasSignal + // + || + // + isXCHMAMNHasSignal + // + || + // + isXCHMAMXHasSignal + // + ; + + // + if (result) + { + // + // Only Log Signals Time Market Conditions if is in Testing Mode ... + if (xAU5IsTestMode || xAU5EnableSignalAlerts) + { + // + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + string message = xAU5Provider.GenerateConditionsString(mConditions); + + // + LogMessage( + "Long Signal Provided by: \n" + + info.signallers[ArraySize(info.signallers) - 1] + "\n" + + "Pusher: " + (string)ArraySize(info.signallers) + "\n" + + "Market Conditions: " + message); + } + } + + // + return result; +} + +// +// Check Market Conditions by Combination of Power of All tools for SHORTs ... +bool XAU5HasShortSignal( + XProvidedSignal &info // Retrieve Signal Additional Info on this Object +) +{ + // + bool result = false; + + // + // XTD ... + bool isXTDHasSignal = XAU5XTDHasShortSignal(); + if (isXTDHasSignal) + { + // + Add( + EnumToString(XTD), + info.signallers); + } + + // + // XTAM ... + bool isXTAMHasSignal = XAU5XTAMHasShortSignal(); + if (isXTAMHasSignal) + { + // + Add( + EnumToString(XTAM), + info.signallers); + } + + // + // XSI ... + bool isXSIHasSignal = XAU5XSIHasShortSignal(); + if (isXSIHasSignal) + { + // + Add( + EnumToString(XSI), + info.signallers); + } + + // + // XTSFI ... + bool isXTSFIHasSignal = XAU5XTSFIHasShortSignal(); + if (isXTSFIHasSignal) + { + // + Add( + EnumToString(XTSFI), + info.signallers); + } + + // + // XOBD XLH ... + bool isXOBDLHHasSignal = XAU5XOBDLHHasShortSignal(); + if (isXOBDLHHasSignal) + { + // + Add( + EnumToString(XOBDLH), + info.signallers); + } + + // + // XCHMA Cycles Cross ... + bool isXCHMACCHasSignal = XAU5XCHMACCHasShortSignal(); + if (isXCHMACCHasSignal) + { + // + Add( + EnumToString(XCHMACC), + info.signallers); + } + + // + // XCHMA Cycles Min ... + bool isXCHMAMNHasSignal = XAU5XCHMAMNHasShortSignal(); + if (isXCHMAMNHasSignal) + { + // + Add( + EnumToString(XCHMAMN), + info.signallers); + } + + // + // XCHMA Cycles Max + bool isXCHMAMXHasSignal = XAU5XCHMAMXHasShortSignal(); + if (isXCHMAMXHasSignal) + { + // + Add( + EnumToString(XCHMAMX), + info.signallers); + } + + // + result = + // + isXTDHasSignal + // + || + // + isXTAMHasSignal + // + || + // + isXSIHasSignal + // + || + // + isXTSFIHasSignal + // + || + // + isXOBDLHHasSignal + // + || + // + isXCHMACCHasSignal + // + || + // + isXCHMAMNHasSignal + // + || + // + isXCHMAMXHasSignal + // + ; + + // + if (result) + { + // + // Only Log Signals Time Market Conditions if is in Testing Mode ... + if (xAU5IsTestMode || xAU5EnableSignalAlerts) + { + // + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + string message = xAU5Provider.GenerateConditionsString(mConditions); + + // + LogMessage( + "Short Signal Provided by: \n" + + info.signallers[ArraySize(info.signallers) - 1] + "\n" + + "Pusher: " + (string)ArraySize(info.signallers) + "\n" + + "Market Conditions: " + message); + } + } + + // + return result; +} + +// +// +// END Combination Signaling ... +// +// + +// +// START Signal Providers ... +// + +// +// Disbale All Signallers Longs ... +void XAU5DisableLongSignallers() +{ + // + // XTD ... + if (xAU5MXTDEnableSignaller) + { + // + xAU5Provider.DisbaleXTDLongs(); + xAU5MXTDAllowLongSignals = false; + } + + // + // XTAM ... + if (xAU5MXTAMEnableSignaller) + { + // + xAU5Provider.DisbaleXTAMLongs(); + xAU5MXTAMAllowLongSignals = false; + } + + // + // XSI ... + if (xAU5MXSIEnableSignaller) + { + // + xAU5Provider.DisbaleXSILongs(); + xAU5MXSIAllowLongSignals = false; + } + + // + // XTSFI ... + if (xAU5MXTSFIEnableSignaller) + { + // + xAU5Provider.DisbaleXTSFILongs(); + xAU5MXTSFIAllowLongSignals = false; + } + + // + // XOBDLH ... + if (xAU5MXOBDLHEnableSignaller) + { + // + xAU5Provider.DisbaleXOBDLHLongs(); + xAU5MXOBDLHAllowLongSignals = false; + } + + // + // XCHMACC ... + if (xAU5MXCHMACCEnableSignaller) + { + // + xAU5Provider.DisbaleXCHMACCLongs(); + xAU5MXCHMACCAllowLongSignals = false; + } + + // + // XCHMAMX ... + if (xAU5MXCHMAMXEnableSignaller) + { + // + xAU5Provider.DisbaleXCHMAMXLongs(); + xAU5MXCHMAMXAllowLongSignals = false; + } + + // + // XCHMAMN ... + if (xAU5MXCHMAMNEnableSignaller) + { + // + xAU5Provider.DisbaleXCHMAMNLongs(); + xAU5MXCHMAMNAllowLongSignals = false; + } +} + +// +// Enable All Signallers Longs ... +// Only if they are Configured as Enable at Settings ... +void XAU5EnableLongSignallers() +{ + // + // XTD ... + if (xAU5MXTDEnableSignaller) + { + // + xAU5MXTDAllowLongSignals = + xAU5XTDAllowLongSignals + ? true + : xAU5MXTDAllowLongSignals; + + // + if (xAU5MXTDAllowLongSignals) + { + xAU5Provider.EnableXTDLongs(); + } + } + + // + // XTAM ... + if (xAU5MXTAMEnableSignaller) + { + // + xAU5MXTAMAllowLongSignals = + xAU5XTAMAllowLongSignals + ? true + : xAU5MXTAMAllowLongSignals; + + // + if (xAU5MXTAMAllowLongSignals) + { + xAU5Provider.EnableXTAMLongs(); + } + } + + // + // XSI ... + if (xAU5MXSIEnableSignaller) + { + // + xAU5MXSIAllowLongSignals = + xAU5XSIAllowLongSignals + ? true + : xAU5MXSIAllowLongSignals; + + // + if (xAU5MXSIAllowLongSignals) + { + xAU5Provider.EnableXSILongs(); + } + } + + // + // XTSFI ... + if (xAU5MXTSFIEnableSignaller) + { + // + xAU5MXTSFIAllowLongSignals = + xAU5XTSFIAllowLongSignals + ? true + : xAU5MXTSFIAllowLongSignals; + + // + if (xAU5MXTSFIAllowLongSignals) + { + xAU5Provider.EnableXTSFILongs(); + } + } + + // + // XOBDLH ... + if (xAU5MXOBDLHEnableSignaller) + { + // + xAU5MXOBDLHAllowLongSignals = + xAU5XOBDLHAllowLongSignals + ? true + : xAU5MXOBDLHAllowLongSignals; + + // + if (xAU5MXOBDLHAllowLongSignals) + { + xAU5Provider.EnableXOBDLHLongs(); + } + } + + // + // XCHMACC ... + if (xAU5MXCHMACCEnableSignaller) + { + // + xAU5MXCHMACCAllowLongSignals = + xAU5XCHMACCAllowLongSignals + ? true + : xAU5MXCHMACCAllowLongSignals; + + // + if (xAU5MXCHMACCAllowLongSignals) + { + xAU5Provider.EnableXCHMACCLongs(); + } + } + + // + // XCHMAMX ... + if (xAU5MXCHMAMXEnableSignaller) + { + // + xAU5MXCHMAMXAllowLongSignals = + xAU5XCHMAMXAllowLongSignals + ? true + : xAU5MXCHMAMXAllowLongSignals; + + // + if (xAU5MXCHMAMXAllowLongSignals) + { + xAU5Provider.EnableXCHMAMXLongs(); + } + } + + // + // XCHMAMN ... + if (xAU5MXCHMAMNEnableSignaller) + { + // + xAU5MXCHMAMNAllowLongSignals = + xAU5XCHMAMNAllowLongSignals + ? true + : xAU5MXCHMAMNAllowLongSignals; + + // + if (xAU5MXCHMAMNAllowLongSignals) + { + xAU5Provider.EnableXCHMAMNLongs(); + } + } +} + +// +// Disable All Signallers Shorts ... +void XAU5DisableShortSignallers() +{ + // + // XTD ... + if (xAU5MXTDEnableSignaller) + { + // + xAU5Provider.DisableXTDShorts(); + xAU5MXTDAllowShortSignals = false; + } + + // + // XTAM ... + if (xAU5MXTAMEnableSignaller) + { + // + xAU5Provider.DisableXTAMShorts(); + xAU5MXTAMAllowShortSignals = false; + } + + // + // XSI ... + if (xAU5MXSIEnableSignaller) + { + // + xAU5Provider.DisableXSIShorts(); + xAU5MXSIAllowShortSignals = false; + } + + // + // XTSFI ... + if (xAU5MXTSFIEnableSignaller) + { + // + xAU5Provider.DisableXTSFIShorts(); + xAU5MXTSFIAllowShortSignals = false; + } + + // + // XOBDLH ... + if (xAU5MXOBDLHEnableSignaller) + { + // + xAU5Provider.DisableXOBDLHShorts(); + xAU5MXOBDLHAllowShortSignals = false; + } + + // + // XCHMACC ... + if (xAU5MXCHMACCEnableSignaller) + { + // + xAU5Provider.DisableXCHMACCShorts(); + xAU5MXCHMACCAllowShortSignals = false; + } + + // + // XCHMAMX ... + if (xAU5MXCHMAMXEnableSignaller) + { + // + xAU5Provider.DisableXCHMAMXShorts(); + xAU5MXCHMAMXAllowShortSignals = false; + } + + // + // XCHMAMN ... + if (xAU5MXCHMAMNEnableSignaller) + { + // + xAU5Provider.DisableXCHMAMNShorts(); + xAU5MXCHMAMNAllowShortSignals = false; + } +} + +// +// Enable All Signallers Shorts ... +// Only if they are Configured as Enable at Settings ... +void XAU5EnableShortSignallers() +{ + // + // XTD ... + if (xAU5MXTDEnableSignaller) + { + // + xAU5MXTDAllowShortSignals = + xAU5XTDAllowShortSignals + ? true + : xAU5MXTDAllowShortSignals; + + // + if (xAU5MXTDAllowShortSignals) + { + xAU5Provider.EnableXTDShorts(); + } + } + + // + // XTAM ... + if (xAU5MXTAMEnableSignaller) + { + // + xAU5MXTAMAllowShortSignals = + xAU5XTAMAllowShortSignals + ? true + : xAU5MXTAMAllowShortSignals; + + // + if (xAU5MXTAMAllowShortSignals) + { + xAU5Provider.EnableXTAMShorts(); + } + } + + // + // XSI ... + if (xAU5MXSIEnableSignaller) + { + // + xAU5MXSIAllowShortSignals = + xAU5XSIAllowShortSignals + ? true + : xAU5MXSIAllowShortSignals; + + // + if (xAU5MXSIAllowShortSignals) + { + xAU5Provider.EnableXSIShorts(); + } + } + + // + // XTSFI ... + if (xAU5MXTSFIEnableSignaller) + { + // + xAU5MXTSFIAllowShortSignals = + xAU5XTSFIAllowShortSignals + ? true + : xAU5MXTSFIAllowShortSignals; + + // + if (xAU5MXTSFIAllowShortSignals) + { + xAU5Provider.EnableXTSFIShorts(); + } + } + + // + // XOBDLH ... + if (xAU5MXOBDLHEnableSignaller) + { + // + xAU5MXOBDLHAllowShortSignals = + xAU5XOBDLHAllowShortSignals + ? true + : xAU5MXOBDLHAllowShortSignals; + + // + if (xAU5MXOBDLHAllowShortSignals) + { + xAU5Provider.EnableXOBDLHShorts(); + } + } + + // + // XCHMACC ... + if (xAU5MXCHMACCEnableSignaller) + { + // + xAU5MXCHMACCAllowShortSignals = + xAU5XCHMACCAllowShortSignals + ? true + : xAU5MXCHMACCAllowShortSignals; + + // + if (xAU5MXCHMACCAllowShortSignals) + { + xAU5Provider.EnableXCHMACCShorts(); + } + } + + // + // XCHMAMX ... + if (xAU5MXCHMAMXEnableSignaller) + { + // + xAU5MXCHMAMXAllowShortSignals = + xAU5XCHMAMXAllowShortSignals + ? true + : xAU5MXCHMAMXAllowShortSignals; + + // + if (xAU5MXCHMAMXAllowShortSignals) + { + xAU5Provider.EnableXCHMAMXShorts(); + } + } + + // + // XCHMAMN ... + if (xAU5MXCHMAMNEnableSignaller) + { + // + xAU5MXCHMAMNAllowShortSignals = + xAU5XCHMAMNAllowShortSignals + ? true + : xAU5MXCHMAMNAllowShortSignals; + + // + if (xAU5MXCHMAMNAllowShortSignals) + { + xAU5Provider.EnableXCHMAMNShorts(); + } + } +} + +// +// +// + +// +// XTD Long Signal Checking ... +bool XAU5XTDHasLongSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXTDEnableSignaller || + !xAU5MXTDAllowLongSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XTDHasLongConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTD Long ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXTDBearishVale && + mConditions.isXCHMAMCTrendsDown) + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXAMANeutural && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXTDBullOverBear && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedUnderFarest) + // + || + // + ( + (mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMax) && + ( + // + (mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMASCCrossedOverMax && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTDBullOverBear && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTDSignalCrossedOverBear) + // + ) + // + ) + // + || + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMAMCVale && + mConditions.isXCHMAMCTrendsUp) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax && + mConditions.isXTMStartBullish && + mConditions.isXTDBullOverBear && + mConditions.isXAMAStartBullish) + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTSCurrentMax && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedOverNearest && + mConditions.isXTSCurrentCrossedOverMediest) + // + ) + // + ) + // + || + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax && + mConditions.isXTMStartBullish && + mConditions.isXAMAStartBullish && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCVale && + mConditions.isXAMANeutural && + mConditions.isXCHMALCTrendsDown && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedOverFarest && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Long ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMax && + mConditions.isXTDBearishVale && + mConditions.isXLHLLDecreased && + mConditions.isXCHMAMCTrendsDown && + (mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow)) + // + || + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMAMCVale && + mConditions.isXCHMAMCTrendsUp) + // + || + // + (mConditions.isXCHMAMCVale && + mConditions.isXCHMALCPeak && + mConditions.isXAMANeutural) + // + || + // + (mConditions.isXCHMAMCVale && + mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMax && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTDSignalCrossedOverBear) + // + ) + // + ) + // + || + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax && + mConditions.isXLHHHDecreased && + mConditions.isXTDSignalCrossedOverBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Long ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXFIOverZero && + mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalCrossedOverBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Long ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + false + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTD Long ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMAMCVale && + mConditions.isXCHMAMCTrendsUp) + // + || + // + (mConditions.isXCHMAMCVale && + mConditions.isXTSCurrentMax && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXTDBearishVale && + ( + // + (mConditions.isXTMNeutural && + mConditions.isXLHPriceCrossedUnderSignal) + // + || + // + (mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXTSCurrentUnderFarest) + // + || + // + (mConditions.isXCHMAMCVale && + mConditions.isXCHMALCVale && + mConditions.isXLHLLIncreased) + // + ) + // + ) + // + || + // + // Check if LC Fast Over Slow .. + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check if LC Fast Over Slow .. + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMALCPeak && + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXCHMAMCTrendsDown) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHMAMCTrendsDown) + // + || + // + (mConditions.isXCHLHMCLCHHSame && + mConditions.isXAMAStartBullish && + mConditions.isXTSCurrentUnderFarest) + // + || + // + (mConditions.isXCHMAMCVale && + mConditions.isXTSCurrentMax && + mConditions.isXAMAStartBullish && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTDSignalCrossedOverBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCVale) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXCHMALCTrendsUp) + // + || + // + (mConditions.isXAMABearish && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderNearest) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXAMANeutural && + mConditions.isXTSCurrentMax && + mConditions.isXTMStartBullish && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXAMANeutural && + mConditions.isXTSCurrentMax && + mConditions.isXLHLLIncreased && + mConditions.isXTMStartBullish && + mConditions.isXTDSignalCrossedOverBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Long ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXAMAVale && + mConditions.isXAMABearish && + mConditions.isXTSCurrentMax && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMAMCVale && + mConditions.isXCHMALCVale) + // + || + // + (mConditions.isXCHMAMCVale && + mConditions.isXCHMAMCTrendsUp) + // + ) + // + ) + // + || + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax && + mConditions.isXLHLLIncreased && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedOverFarest && + mConditions.isXTSCurrentCrossedOverNearest && + mConditions.isXTSCurrentCrossedOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Long ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + (mConditions.isXAMANeutural && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTDSignalCrossedOverBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Long ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + mConditions.isXRSICrossedOverLongExit + // + || + // + // XTD Long ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMAMCVale && + mConditions.isXCHMAMCTrendsUp) + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXTDBearishVale && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderNearest) + // + ) + // + ) + // + || + // + // Check LC Fast Over Slow ... + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHMASCCrossedOverMax && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTSCurrentMax && + mConditions.isXLHLLIncreased && + mConditions.isXTDBearishVale && + mConditions.isXCHMALCTrendsDown && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXLHPriceCrossedOverSignal) + // + || + // + ((mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown) && + ( + // + (mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedOverNearest && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + (mConditions.isXTSCurrentUnderNearest && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTSCurrentMax && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHLHSameHHs && + mConditions.isXTSCurrentMax && + mConditions.isXCHMASCCrossedOverMax) + // + || + // + (mConditions.isXTMStartBullish && + mConditions.isXAMAStartBullish && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXLHPriceCrossedOverSignal && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + ((mConditions.isXTSCurrentUnderNearest || + mConditions.isXTSCurrentCrossedUnderNearest) && + (mConditions.isXTSCurrentUnderMediest || + mConditions.isXTSCurrentCrossedUnderMediest)) + // + || + // + ((mConditions.isXLHLLIncreased && + mConditions.isXTMStartBullish && + mConditions.isXAMAStartBullish && + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + mConditions.isXTSCurrentCrossedUnderFarest + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXTDBearishVale && + mConditions.isXTSCurrentUnderNearest) + // + || + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHLHSameHHs && + mConditions.isXTSCurrentUnderMediest && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXCHMASCCrossedOverMin && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMASCCrossedOverMax && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + (mConditions.isXCHMAMCPeak && + mConditions.isXTSCurrentMax && + mConditions.isXLHLLDecreased && + mConditions.isXCHMASCCrossedOverMax && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + (mConditions.isXCHMAMCPeak && + mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderMediest && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedUnderFarest && + mConditions.isXTSCurrentCrossedUnderMediest) + // + || + // + ((mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCVale) && + ( + // + (mConditions.isXFIUnderZero && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (mConditions.isXTSCurrentUnderNearest && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXTSCurrentMax && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + ((mConditions.isXTMNeutural && + mConditions.isXAMANeutural) && + ( + // + (mConditions.isXTSCurrentMax && + mConditions.isXFICrossedOverZero && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + ((mConditions.isXTDBearishVale && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHLHMCLCLLSame) && + ( + // + mConditions.isXTSCurrentMax + // + || + // + mConditions.isXTSCurrentUnderFarest + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Long ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + // Check LC Fast Over Slow ... + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXCHMASCOverMax && + mConditions.isXTSCurrentUnderNearest) + // + || + // + ((mConditions.isXTSCurrentMax && + mConditions.isXLHHighAttachedHH && + mConditions.isXTDSignalCrossedOverBear) && + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXTMStartBullish && + mConditions.isXAMAStartBullish && + mConditions.isXCHMASCCrossedOverMax && + mConditions.isXLHPriceCrossedOverSignal) + // + || + // + (mConditions.isXCHLHSameHHs && + mConditions.isXCHMASCOverMax && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTSCurrentCrossedOverFarest && + mConditions.isXTSCurrentCrossedOverNearest && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + (mConditions.isXCHMASCPeak && + mConditions.isXCHMASCOverMax && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + || + // + ((mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMALCPeak && + mConditions.isXCHLHSameHHs && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalCrossedOverBear) && + ( + // + (mConditions.isXTSAllSame && + mConditions.isXLHHHIncreased) + // + || + // + (mConditions.isXTSCurrentMax && + ( + // + mConditions.isXLHHighAttachedHH + // + || + // + (mConditions.isXLHHHIncreased && + mConditions.isXCHMASCOverMax) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + (mConditions.isXAMAEndBullish && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMAMCTrendsUp) + // + ) + // + ) + // + || + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHLHSCMCHHSame && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + (mConditions.isXCHMALCVale && + mConditions.isXTMStartBullish && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXAMAStartBullish && + mConditions.isXLHHighAttachedHH && + mConditions.isXFICrossedOverZero) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXCHMAMCPeak && + mConditions.isXAMABullish && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMASCCrossedOverMax && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + ((mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTSCurrentMax) && + ( + // + (mConditions.isXFIOverZero && + mConditions.isXLHLLDecreased && + mConditions.isXCHLHSCMCHHSame) + // + || + // + (mConditions.isXTDSignalCrossedOverBear && + ( + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHLHSCMCHHSame) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXCHLHSCMCLLSame) + // + ) + // + ) + // + || + // + ((mConditions.isXCHLHSCMCHHSame && + mConditions.isXLHHighAttachedHH && + mConditions.isXTDSignalCrossedOverBear) && + ( + // + mConditions.isXCHLHMCLCLLSame + // + || + // + (mConditions.isXCHMAMCPeak && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXTDBullOverBear) + // + || + // + (mConditions.isXCHMASCOverMin && + mConditions.isXCHMASCUnderMax && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXCHMASCOverMax && + mConditions.isXTSCurrentCrossedOverNearest && + mConditions.isXTSCurrentCrossedOverMediest) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + ((mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCVale) && + ( + // + (mConditions.isXTMNeutural && + mConditions.isXTMEndBullish && + mConditions.isXTSCurrentMin && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentCrossedUnderFarest) + // + || + // + ((mConditions.isXTMNeutural && + mConditions.isXTSCurrentMax && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentOverMediest) && + ( + // + (mConditions.isXTDBullOverBear && + mConditions.isXFICrossedOverZero && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + (mConditions.isXTSCurrentCrossedOverFarest && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Long ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderMediest) + // + || + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMAMCPeak && + mConditions.isXTSCurrentMax && + mConditions.isXTMStartBullish && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTSCurrentMax && + mConditions.isXCHMALCTrendsDown && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMASCCrossedOverMax && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + ((mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTSCurrentMax && + mConditions.isXTDSignalCrossedOverBear) && + ( + // + (mConditions.isXCHMASCCrossedOverMin && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXLHPriceCrossedOverSignal) + // + || + // + (mConditions.isXCHMAMCPeak && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXCHLHSCMCHHSame) + // + || + // + (mConditions.isXCHMALCTrendsDown && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Long ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check LC Fast Over Slow ... + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMax && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMALCPeak && + mConditions.isXCHLHSameLLs && + mConditions.isXTSCurrentMax && + mConditions.isXLHHighAttachedHH && + (mConditions.isXTDBullOverBear || + mConditions.isXTDSignalCrossedOverBear)) + // + ) + // + ) + // + || + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + ((mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTSCurrentMax) && + ( + // + (mConditions.isXLHHighAttachedHH && + ( + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHLHSameHHs) + // + || + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedOverNearest && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax && + mConditions.isXTDBearishVale && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax && + mConditions.isXLHLLIncreased && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTDSignalCrossedOverBear) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTD Long ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXAMANeutural && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTSCurrentUnderFarest) + // + ) + // + ) + // + || + // + // XTD Long ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTD Long ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTD Long ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XTD Short Signal Checking ... +bool XAU5XTDHasShortSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXTDEnableSignaller || + !xAU5MXTDAllowShortSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XTDHasShortConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTD Short ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTSCurrentOverFarest) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXAMAEndBullish && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXCHMASCTrendsUp) + // + ) + // + ) + // + || + // + // Check if MC Fast Over Slow ... + ((mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) && + ( + // + (mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXTSCurrentOverFarest) + // + || + // + (mConditions.isXCHMALCVale && + ( + // + mConditions.isXCHMALCTrendsDown + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Short ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if MC Fast Over Slow ... + ((mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMAMCTrendsUp) + // + || + // + (mConditions.isXTDBullOverBear && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverNearest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Short ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if MC Fast Over Slow ... + ((mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHLHSameLLs && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXLHLowAttachedLL) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Short ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTD Short ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTDBullOverBear && + mConditions.isXCHMASCTrendsDown && + mConditions.isXTSCurrentOverNearest && + mConditions.isXCHMASCFastCrossedUnderSlow) + // + || + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + (mConditions.isXTDBullOverBear && + mConditions.isXTSCurrentOverNearest) + // + || + // + (mConditions.isXTMEndBearish && + mConditions.isXAMAEndBearish && + mConditions.isXTSCurrentOverNearest) + // + || + // + (mConditions.isXCHMASCPeak && + mConditions.isXTSCurrentMin && + mConditions.isXLHHHDecreased && + mConditions.isXTDBullOverBear) + // + || + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXCHMASCPeak && + mConditions.isXLHHHDecreased && + mConditions.isXTDBullOverBear && + mConditions.isXTSCurrentOverFarest) + // + || + // + ((mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMin && + mConditions.isXTMStartBearish && + mConditions.isXTDBullOverBear && + mConditions.isXAMAStartBearish) && + ( + // + (mConditions.isXCHLHMCLCLLSame && + mConditions.isXCHMAMCTrendsDown) + // + || + // + (mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalCrossedUnderBear) + // + || + // + (mConditions.isXCHMASCPeak && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDSignalCrossedUnderBear && + mConditions.isXTSCurrentCrossedUnderFarest && + mConditions.isXTSCurrentCrossedUnderMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check if MC Fast Over Slow ... + ((mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMASCPeak && + mConditions.isXAMANeutural && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXCHMALCTrendsDown && + mConditions.isXLHPriceCrossedUnderSignal) + // + ) + // + ) + // + || + // + // Check LC Fast Over Slow ... + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXTDBullOverBear && + mConditions.isXTMStartBearish && + mConditions.isXAMAStartBearish && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Short ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTD Short ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) && + ( + // + ((mConditions.isXCHMALCVale && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXAMAStartBearish) && + ( + // + mConditions.isXTSCurrentOverFarest + // + || + // + (mConditions.isXTSCurrentMin && + mConditions.isXCHMALCTrendsUp) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Short ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTD Short ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTSCurrentOverFarest) + // + ) + // + ) // + ) + // + ) + // + || + // + // XTD Short ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Short ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if MC Fast Over Slow ... + ((mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMAMCTrendsUp) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMin && + mConditions.isXLHHHIncreased && + mConditions.isXTDBullOverBear && + mConditions.isXCHMALCTrendsDown) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTD Short ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTD Short ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTD Short ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTD Short ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTD Short ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XTAM Long Signal Checking ... +bool XAU5XTAMHasLongSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXTAMEnableSignaller || + !xAU5MXTAMAllowLongSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XTAMHasLongConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTAM Long ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + mConditions.isXCHMASCTrendsUp + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + || + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + mConditions.isXCHMAMCTrendsUp + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXTDBearishVale && + mConditions.isXTSCurrentUnderFarest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTAM Long ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMAMCVale && + mConditions.isXCHMAMCTrendsUp) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTAM Long ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + mConditions.isXCHMASCTrendsUp + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTAM Long ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTAM Long ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural) + // + ) + // + ) + // + || + // + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + mConditions.isXCHMAMCTrendsUp + // + || + // + (mConditions.isXCHMAMCVale && + mConditions.isXCHMAMCTrendsUp) + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderFarest) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTSCurrentMax && + mConditions.isXTDBearishVale && + mConditions.isXLHLLIncreased && + mConditions.isXTDBullOverBear && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTAM Long ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMAMCVale && + mConditions.isXCHMAMCTrendsUp) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTDBearishVale && + mConditions.isXTDSignalUnderBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTAM Long ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + mConditions.isXCHMASCTrendsUp + // + || + // + (mConditions.isXCHMASCVale && + mConditions.isXCHLHSCMCLLSame) + // + || + // + (mConditions.isXTMVale && + mConditions.isXAMAVale && + mConditions.isXTMNeutural && + mConditions.isXAMANeutural) + // + || + // + (mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderFarest) + // + ) + // + ) + // + || + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + mConditions.isXCHMAMCTrendsUp + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTSCurrentMax && + mConditions.isXTDBearishVale && + mConditions.isXLHLLIncreased && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTAM Long ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTAM Long ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTDSignalUnderBear) + // + || + // + (mConditions.isXTDSignalVale && + mConditions.isXTDBullishVale && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear) + // + || + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXCHMALCPeak && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHMAMCTrendsDown) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTSCurrentMax && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTDSignalUnderBear && + mConditions.isXLHPriceCrossedOverSignal && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMax && + mConditions.isXTDBearishVale && + mConditions.isXLHHHDecreased && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMASCCrossedOverMax && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMax && + mConditions.isXCHMASCOverMax && + mConditions.isXCHMASCTrendsUp && + mConditions.isXTDBullOverBear && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXCHMALCTrendsUp && + mConditions.isXTDSignalOverBear) + // + || + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + mConditions.isXCHMASCTrendsUp + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTAM Long ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow && + mConditions.isXTSCurrentCrossedOverNearest && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHLHSameHHs && + mConditions.isXTSCurrentMax && + mConditions.isXTDBearishVale && + mConditions.isXTDBullOverBear && + mConditions.isXLHHighAttachedHH) + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMax && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXLHHighAttachedHH && + mConditions.isXCHMALCTrendsDown) + // + || + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXLHHighAttachedHH && + mConditions.isXTSCurrentCrossedOverNearest && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMASCPeak && + mConditions.isXCHLHSameHHs && + mConditions.isXTSCurrentMax && + mConditions.isXTDBearishVale && + mConditions.isXLHHighAttachedHH && + mConditions.isXTSCurrentCrossedOverNearest && + mConditions.isXTSCurrentCrossedOverMediest) + // + ) + // + ) + // + || + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMAMCPeak && + mConditions.isXTSCurrentMax && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXLHHighAttachedHH && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTAM Long ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTAM Long ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTAM Long ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTAM Long ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTAM Long ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTAM Long ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XTAM Short Signal Checking ... +bool XAU5XTAMHasShortSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXTAMEnableSignaller || + !xAU5MXTAMAllowShortSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XTAMHasShortConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTAM Short ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + mConditions.isXCHMASCTrendsUp + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXAMABullish && + mConditions.isXTSCurrentMin && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXCHMALCVale && + mConditions.isXAMANeutural && + mConditions.isXLHLLDecreased && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXCHMASCPeak && + mConditions.isXAMANeutural && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTSCurrentOverFarest) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXLHLLDecreased && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTDBullCrossedOverBear && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + || + // + // Check if MC Fast Over Slow ... + ((mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) && + ( + // + mConditions.isXCHMALCTrendsDown + // + || + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMAMCTrendsUp) + // + || + // + (mConditions.isXCHMASCVale && + mConditions.isXTDSignalVale && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullishVale) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTAM Short ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTAM Short ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTAM Short ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTAM Short ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXAMANeutural && + mConditions.isXCHMALCTrendsDown && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXCHLHSCMCLLSame && + mConditions.isXCHMASCUnderMin && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + mConditions.isXCHMASCTrendsUp + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXTDBullOverBear && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTDSignalCrossedOverBear) + // + ) + // + ) + // + || + // + // Check if MC Fast Over Slow ... + ((mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMASCVale && + mConditions.isXTDSignalVale && + mConditions.isXTDBullishVale) + // + || + // + (mConditions.isXCHMAMCPeak && + mConditions.isXTSCurrentMin && + mConditions.isXCHMALCTrendsDown && + mConditions.isXLHPriceCrossedUnderSignal) + // + ) + // + ) + // + || + // + // Check LC Fast Over Slow ... + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMASCVale && + mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMin && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentCrossedUnderNearest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTAM Short ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTAM Short ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (mConditions.isXCHLHSCMCLLSame && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + // Check if MC Fast Over Slow ... + ((mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) && + ( + // + (mConditions.isXTMVale && + mConditions.isXAMAVale && + mConditions.isXCHMASCVale && + mConditions.isXTSCurrentMin && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXLHLowAttachedLL && + mConditions.isXCHMASCCrossedUnderMin) + // + ) + // + ) + // + || + // + // Check LC Fast Over Slow ... + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXTDSignalVale && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullishVale && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXLHLowAttachedLL && + mConditions.isXTDSignalUnderBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTAM Short ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (mConditions.isXTMVale && + mConditions.isXAMAVale && + mConditions.isXCHMASCVale && + mConditions.isXTSCurrentMin && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXCHLHSameLLs && + mConditions.isXTSCurrentMin && + mConditions.isXCHMASCTrendsUp && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXCHMALCTrendsUp && + mConditions.isXTDBullUnderBear && + mConditions.isXLHLowAttachedLL && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMASCFastUnderSlow && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXCHMALCFastUnderSlow && + mConditions.isXLHPriceCrossedUnderSignal) + // + || + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + (mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + (mConditions.isXTSCurrentMin && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTMStartBearish && + mConditions.isXAMAStartBearish && + mConditions.isXLHLowAttachedLL && + mConditions.isXLHPriceCrossedUnderSignal) + // + ) + // + ) + // + || + // + // Check LC Fast Over Slow ... + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + ((mConditions.isXTMVale && + mConditions.isXAMAVale && + mConditions.isXCHLHSameLLs && + mConditions.isXTSCurrentMin) && + ( + // + mConditions.isXLHLowAttachedLL + // + || + // + (mConditions.isXCHMAMCVale && + mConditions.isXTDSignalVale && + mConditions.isXTDBullishVale) + // + ) + // + ) + // + || + // + (mConditions.isXLHLowAttachedLL && + ( + // + (mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + (mConditions.isXCHLHSameLLs && + mConditions.isXTSCurrentMin && + mConditions.isXLHHHDecreased && + mConditions.isXTDBullOverBear) + // + || + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXCHMAMCVale && + mConditions.isXTSCurrentMin && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTAM Short ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + mConditions.isXCHMASCTrendsUp + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXLHLLIncreased && + mConditions.isXTSCurrentOverFarest && + mConditions.isXLHPriceCrossedOverSignal) + // + || + // + (mConditions.isXTMStartBullish && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXAMAStartBullish && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentOverMediest && + mConditions.isXLHPriceCrossedOverSignal && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + (mConditions.isXTSAllSame && + mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMALCVale && + mConditions.isXLHLLIncreased && + mConditions.isXTDBullUnderBear && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMAMCFastUnderSlow) + // + || + // + (mConditions.isXCHMASCPeak && + ( + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTDBullOverBear && + mConditions.isXCHMASCTrendsUp && + mConditions.isXTDSignalOverBear) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check if MC Fast Over Slow ... + ((mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMAMCTrendsUp) + // + || + // + (mConditions.isXTSAllSame && + mConditions.isXCHMALCVale && + mConditions.isXTDSignalVale && + mConditions.isXTDBullishVale) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMAMCTrendsDown) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTAM Short ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + mConditions.isXCHMASCTrendsUp + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTAM Short ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTAM Short ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTAM Short ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTAM Short ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTAM Short ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTAM Short ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XSI Long Signal Checking ... +bool XAU5XSIHasLongSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXSIEnableSignaller || + !xAU5MXSIAllowLongSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XSIHasLongConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XSI Long ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Long ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Long ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Long ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XSI Long ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + (mConditions.isXTMVale && + mConditions.isXCHMASCVale && + mConditions.isXCHMAMCVale && + mConditions.isXTMNeutural && + mConditions.isXAMANeutural) + // + || + // + (mConditions.isXCHLHSCMCLLSame && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTDBullUnderBear && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMALCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderFarest) + // + ) + // + ) + // + || + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + (mConditions.isXTMVale && + mConditions.isXCHMAMCVale && + mConditions.isXCHMALCVale) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXLHLLDecreased && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHMASCUnderMax && + mConditions.isXTDBullUnderBear && + mConditions.isXCHMALCTrendsDown && + mConditions.isXTDSignalUnderBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XSI Long ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Long ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMASCVale && + mConditions.isXCHMASCTrendsUp) + // + || + // + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXTMVale && + mConditions.isXAMAVale && + mConditions.isXCHMASCVale && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear) + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXLHLLDecreased && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXCHMALCTrendsDown) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XSI Long ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMASCVale && + mConditions.isXCHMASCTrendsUp) + // + || + // + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXTMVale && + mConditions.isXAMAVale && + mConditions.isXCHMASCVale && + mConditions.isXTDSignalVale && + mConditions.isXTDBullishVale) + // + || + // + (mConditions.isXCHLHSCMCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXLHLowAttachedLL && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XSI Long ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Long ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Long ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Long ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + mConditions.isXCHMASCTrendsUp + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTMStartBullish && + mConditions.isXAMAStartBullish && + mConditions.isXTDBullUnderBear && + mConditions.isXLHHighAttachedHH && + mConditions.isXTDSignalUnderBear) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XSI Long ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Long ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Long ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Long ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XSI Short Signal Checking ... +bool XAU5XSIHasShortSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXSIEnableSignaller || + !xAU5MXSIAllowShortSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XSIHasShortConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XSI Short ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Short ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXCHMALCFastUnderSlow) + // + || + // + (mConditions.isXTSAllSame && + mConditions.isXCHMALCVale && + mConditions.isXTMStartBearish && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXAMAStartBearish && + mConditions.isXTDSignalOverBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XSI Short ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Short ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XSI Short ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Short ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Short ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Short ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XSI Short ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMASCPeak && + mConditions.isXCHMAMCPeak) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXCHMALCFastUnderSlow) + // + || + // + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXCHMALCFastUnderSlow) + // + ) + // + ) + // + || + // + // Check if MC Fast Over Slow ... + ((mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMAMCTrendsUp) + // + || + // + (mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMASCFastUnderSlow && + mConditions.isXCHMALCFastUnderSlow) + // + || + // + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXCHMALCFastUnderSlow) + // + || + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCPeak && + mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTDBullOverBear && + mConditions.isXTSCurrentOverNearest && + mConditions.isXLHPriceCrossedOverSignal && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XSI Short ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMASCPeak && + mConditions.isXCHMASCTrendsUp) + // + || + // + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXCHMALCFastUnderSlow) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTDSignalVale && + mConditions.isXTDBullishVale && + mConditions.isXTSCurrentOverFarest) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXTDBearishVale && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTDSignalOverBear && + mConditions.isXLHHighAttachedHH && + mConditions.isXTSCurrentOverFarest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XSI Short ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXCHMALCFastUnderSlow) + // + || + // + (mConditions.isXCHMASCPeak && + mConditions.isXLHHHIncreased && + mConditions.isXLHLLIncreased && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentOverFarest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XSI Short ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMASCPeak && + mConditions.isXCHMASCTrendsUp) + // + || + // + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXCHMALCFastUnderSlow) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XSI Short ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Short ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Short ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XSI Short ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XTSFI Long Signal Checking ... +bool XAU5XTSFIHasLongSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXTSFIEnableSignaller || + !xAU5MXTSFIAllowLongSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XTSFIHasLongConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTSFI Long ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMASCOverMax && + mConditions.isXCHMASCTrendsUp) + // + || + // + (mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (mConditions.isXLHHHIncreased && + mConditions.isXTMStartBearish && + mConditions.isXAMAStartBearish && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Long ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow) + // + || + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + || + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMASCOverMax && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (((mConditions.isXTMNeutural && + mConditions.isXAMANeutural) || + (mConditions.isXTMEndBullish && + mConditions.isXAMAEndBullish)) && + mConditions.isXCHMASCOverMax && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTSCurrentUnderMediest && + mConditions.isXTSCurrentCrossedUnderMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Long ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHLHSCMCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMAMCFastOverSlow && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (mConditions.isXLHHHIncreased && + mConditions.isXTMStartBearish && + mConditions.isXAMAStartBearish && + mConditions.isXTSCurrentUnderMediest && + mConditions.isXTDSignalCrossedUnderBear) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMAMCFastOverSlow && + mConditions.isXTSCurrentUnderMediest && + mConditions.isXTDBullCrossedUnderBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Long ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow) + // + || + // + (mConditions.isXCHLHSameHHs && + mConditions.isXTMStartBullish && + mConditions.isXAMAStartBullish && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) + // + || + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXCHLHSameHHs && + mConditions.isXCHMASCOverMax && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTSFI Long ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) && + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural) + // + || + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXTDBullUnderBear && + mConditions.isXCHMAMCFastOverSlow) + // + || + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXCHMALCPeak && + mConditions.isXCHMASCTrendsUp && + mConditions.isXTDBullUnderBear && + mConditions.isXCHMAMCFastOverSlow && + mConditions.isXCHMASCFastCrossedOverSlow) + // + ) + // + ) + // + || + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + ((mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) && + ( + // + ((mConditions.isXTMNeutural && + mConditions.isXAMANeutural) && + ( + // + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow) + // + || + // + (mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHLHMCLCLLSame) + // + ) + // + ) + // + || + // + ((mConditions.isXTMBearish && + mConditions.isXAMABearish) && + ( + // + (mConditions.isXLHHHIncreased && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTDBullCrossedUnderBear) + // + || + // + (mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest && + mConditions.isXLHPriceCrossedUnderSignal) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check if MC Fast Over Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + mConditions.isXCHMAMCTrendsUp + // + || + // + (mConditions.isXAMAVale && + mConditions.isXTMNeutural && + mConditions.isXCHMAMCVale && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow && + mConditions.isXTSCurrentUnderMediest) + // + || + // + ((mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) && + ( + // + mConditions.isXTDBullUnderBear + // + || + // + (mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXLHHHDecreased && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Long ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMAMCVale && + mConditions.isXCHMAMCTrendsUp) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXLHHHDecreased && + mConditions.isXLHLLDecreased && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Long ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXTDSignalVale && + mConditions.isXTDBullishVale && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear) + // + || + // + (mConditions.isXCHLHSameHHs && + mConditions.isXLHHHIncreased && + mConditions.isXCHMASCTrendsUp && + mConditions.isXTSCurrentUnderMediest && + mConditions.isXLHPriceCrossedUnderSignal) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Long ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTSFI Long ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + ((mConditions.isXCHMASCOverMax && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) && + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsUp && + mConditions.isXTDBullUnderBear && + mConditions.isXCHMALCFastOverSlow) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTDBearishVale && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTDBullOverBear) + // + ) + // + ) + // + || + // + ((mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMALCPeak && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentUnderMediest) && + ( + // + (mConditions.isXLHHHDecreased && + mConditions.isXCHMASCOverMax) + // + || + // + (mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow) + // + || + // + (mConditions.isXCHLHSameLLs && + mConditions.isXCHMASCOverMax && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMALCTrendsUp) + // + ) + // + ) + // + || + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + ((mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) && + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown && + mConditions.isXTDBullCrossedUnderBear) + // + || + // + (mConditions.isXTDBullUnderBear && + ( + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish) + // + || + // + (mConditions.isXCHMASCOverMax && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTSCurrentCrossedUnderMediest) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXAMABullish) + // + ) + // + ) + // + ) + // + ) + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (mConditions.isXAMAVale && + (mConditions.isXTMBearish || + mConditions.isXAMABearish) && + mConditions.isXTDSignalVale && + mConditions.isXTDBullishVale && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + || + // + // Check if MC Fast Under Slow ... + ((mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMASCOverMax && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + || + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXFICrossedUnderZero && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) + // + || + // + ((mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest && + mConditions.isXTSCurrentCrossedUnderMediest) && + ( + // + mConditions.isXTDBullCrossedUnderBear + // + || + // + (mConditions.isXCHMASCOverMax && + mConditions.isXTDBullUnderBear && + mConditions.isXCHMASCFastCrossedOverSlow) + // + ) + // + ) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHLHSameHHs && + mConditions.isXTSCurrentUnderMediest && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + ((mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTSCurrentUnderMediest) && + ( + // + (mConditions.isXCHLHSCMCHHSame && + mConditions.isXTDSignalUnderBear) + // + || + // + (mConditions.isXTDSignalCrossedUnderBear && + mConditions.isXTSCurrentCrossedUnderMediest) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Long ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + ((mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) && + ( + // + mConditions.isXTDBullOverBear + // + || + (mConditions.isXLHHHDecreased && + mConditions.isXCHMASCOverMax) + // + ) + // + ) + // + || + // + (mConditions.isXLHHHDecreased && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow) + // + ) + // + ) + // + || + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHLHSameHHs && + mConditions.isXCHMASCOverMax && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMALCVale && + mConditions.isXCHMAMCPeak && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear && + mConditions.isXLHHighAttachedHH && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Long ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow) + // + || + // + ((mConditions.isXTMNeutural && + mConditions.isXTSCurrentUnderMediest) && + ( + // + (mConditions.isXAMANeutural && + mConditions.isXLHHHIncreased && + mConditions.isXCHLHSCMCHHSame) + // + || + // + (mConditions.isXCHMASCOverMax && + mConditions.isXAMAStartBullish && + mConditions.isXCHMASCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMASCFastOverSlow) + // + ) + // + ) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHLHSameHHs && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest && + mConditions.isXLHPriceCrossedOverSignal) + // + || + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXTSCurrentUnderMediest && + ( + // + (mConditions.isXCHMASCOverMax && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentCrossedUnderMediest) + // + || + // + ((mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTDSignalUnderBear) && + ( + // + mConditions.isXTDBullUnderBear + // + || + // + (mConditions.isXCHLHSCMCHHSame && + mConditions.isXTSCurrentCrossedUnderMediest) + // + ) + // + ) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXLHHHIncreased && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Long ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check LC Fast Under Slow ... + ((mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXLHLLIncreased && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXLHHighAttachedHH && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTSFI Long ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTSFI Long ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTSFI Long ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTSFI Long ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XTSFI Short Signal Checking ... +bool XAU5XTSFIHasShortSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXTSFIEnableSignaller || + !xAU5MXTSFIAllowShortSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XTSFIHasShortConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTSFI Short ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastUnderSlow) + // + || + // + ((mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXLHLLDecreased && + mConditions.isXTSCurrentOverMediest) && + ( + // + (mConditions.isXCHMASCTrendsUp && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear) + // + || + // + (mConditions.isXCHLHMCLCLLSame && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXTDBullCrossedOverBear) + // + ) + // + ) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMANeutural && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTDBullOverBear && + mConditions.isXCHMASCTrendsUp && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTDSignalCrossedOverBear) + // + || + // + ((mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentOverMediest) && + ( + // + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow) + // + || + // + ((mConditions.isXTMNeutural && + mConditions.isXAMANeutural) && + ( + // + (mConditions.isXCHMASCTrendsUp && + mConditions.isXCHLHMCLCLLSame) + // + || + (mConditions.isXTDBearishVale && + mConditions.isXTSCurrentCrossedOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXTDBearishVale && + mConditions.isXLHHHDecreased && + mConditions.isXCHMASCTrendsUp && + mConditions.isXCHMALCTrendsUp && + mConditions.isXCHMALCFastUnderSlow) + // + ) + // + ) + // + || + // + // Check LC Fast Over Slow ... + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + (mConditions.isXCHLHSCMCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTSCurrentCrossedOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Short ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXCHMASCUnderMin && + mConditions.isXAMAStartBearish && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + || + // + // XTSFI Short ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (mConditions.isXCHLHSameLLs && + mConditions.isXTDBullOverBear && + mConditions.isXCHMASCUnderMin && + mConditions.isXTSCurrentOverMediest && + mConditions.isXRSICrossedOverLongEntry) + // + || + // + (mConditions.isXTMEndBearish && + mConditions.isXAMAEndBearish && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + // Check LC Fast Over Slow ... + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + mConditions.isXRSICrossedUnderShortExit + // + || + // + ((mConditions.isXTDSignalVale && + mConditions.isXTDBullishVale && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXCHMASCUnderMin && + mConditions.isXTSCurrentOverMediest) && + ( + // + (mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear) + // + || + // + (mConditions.isXCHMASCCrossedUnderMin && + mConditions.isXTSCurrentCrossedOverMediest) + // + ) + // + ) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXCHLHSameLLs && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTSCurrentCrossedOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Short ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTSFI Short ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXLHLLIncreased && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + ((mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXTSCurrentOverMediest) && + ( + // + (mConditions.isXTDBullUnderBear && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMAMCFastUnderSlow) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXCHMASCUnderMin && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + (mConditions.isXCHMAMCVale && + !mConditions.isXCHMAMCTrendsUp && + !mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear) + // + || + // + ((mConditions.isXCHMALCVale && + mConditions.isXTDBullishVale && + mConditions.isXTDSignalUnderBear) && + ( + // + (mConditions.isXTDSignalVale && + mConditions.isXTDBullUnderBear) + // + || + // + (mConditions.isXCHLHMCLCLLSame && + mConditions.isXCHMASCUnderMin) + // + ) + // + ) + // + || + // + (mConditions.isXTDBullOverBear && + mConditions.isXCHMASCFastCrossedUnderSlow && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXTDSignalUnderBear && + mConditions.isXTDBullCrossedUnderBear && + mConditions.isXTSCurrentCrossedUnderNearest) + // + ) + // + ) + // + || + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastUnderSlow) + // + || + // + (mConditions.isXTDBullOverBear && + mConditions.isXCHMASCTrendsUp && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastUnderSlow && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + || + // + // Check LC Fast Over Slow ... + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXTDBullOverBear && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXCHMALCPeak && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXAMAVale && + mConditions.isXAMABearish && + mConditions.isXCHMAMCVale && + mConditions.isXTMNeutural && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Short ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMAStartBearish && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest && + mConditions.isXLHPriceCrossedUnderSignal && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + // Check if MC Fast Over Slow ... + ((mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) && + ( + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + || + // + // Check LC Fast Over Slow ... + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXTMVale && + mConditions.isXAMAVale && + mConditions.isXLHHHDecreased && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXAMAVale && + mConditions.isXTMNeutural && + mConditions.isXCHMALCPeak && + mConditions.isXAMABearish && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTSCurrentCrossedOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Short ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastUnderSlow) + // + || + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXLHLowAttachedLL && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + // Check LC Fast Over Slow ... + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + (mConditions.isXAMAVale && + mConditions.isXCHMAMCVale && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastUnderSlow && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXAMAVale && + mConditions.isXTMNeutural && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXAMABearish && + mConditions.isXCHMAMCVale && + mConditions.isXTMEndBearish && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXTDBullUnderBear && + mConditions.isXCHMASCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest && + mConditions.isXCHMASCCrossedOverMin) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Short ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + ((mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTSCurrentOverMediest) && + ( + // + (mConditions.isXTDBullOverBear && + mConditions.isXCHMASCUnderMin && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + (mConditions.isXTDSignalUnderBear && + mConditions.isXTDBullCrossedUnderBear && + mConditions.isXRSICrossedUnderShortExit) + // + ) + // + ) + // + || + // + // Check LC Fast Over Slow ... + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXCHMASCUnderMin && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTSFI Short ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMASCPeak && + mConditions.isXCHMASCTrendsUp) + // + || + // + (mConditions.isXAMAVale && + mConditions.isXAMANeutural && + mConditions.isXTMStartBullish && + mConditions.isXTSCurrentOverMediest && + mConditions.isXLHPriceCrossedOverSignal) + // + || + // + (mConditions.isXCHLHSameLLs && + mConditions.isXCHMASCUnderMin && + mConditions.isXCHMALCFastOverSlow && + mConditions.isXTSCurrentOverMediest) + // + || + // + ((mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTDBullOverBear && + mConditions.isXTSCurrentOverMediest) && + ( + // + mConditions.isXTDSignalCrossedOverBear + // + || + // + (mConditions.isXLHLLDecreased && + mConditions.isXCHLHMCLCLLSame) + // + || + // + ((mConditions.isXTDBearishVale && + mConditions.isXTDSignalOverBear) && + ( + // + mConditions.isXLHPriceCrossedOverSignal + // + || + // + (mConditions.isXCHLHMCLCLLSame && + mConditions.isXCHMASCTrendsUp && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check if MC Fast Over Slow ... + ((mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMAMCTrendsUp) + // + || + // + (mConditions.isXTDSignalVale && + mConditions.isXTDBullishVale && + mConditions.isXLHLLIncreased && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + || + // + // Check LC Fast Over Slow ... + ((mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTDBullCrossedOverBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Short ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + // Check if SC Fast Over Slow ... + ((mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) && + ( + // + ((mConditions.isXTMNeutural && + mConditions.isXAMANeutural) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Short ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if MC Fast Over Slow ... + ((mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) && + ( + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMAMCTrendsUp) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XTSFI Short ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XTSFI Short ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTSFI Short ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTSFI Short ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XTSFI Short ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XOBDLH Long Signal Checking ... +bool XAU5XOBDLHHasLongSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXOBDLHEnableSignaller || + !xAU5MXOBDLHAllowLongSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XOBDLHHasLongConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XOBDLH Long ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Long ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Long ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Long ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XOBDLH Long ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Long ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Long ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (mConditions.isXTMVale && + mConditions.isXAMAVale && + mConditions.isXCHMAMCVale && + mConditions.isXCHMALCVale && + mConditions.isXTDSignalVale && + mConditions.isXTDBullishVale) + // + || + // + (mConditions.isXTMVale && + mConditions.isXAMAVale && + mConditions.isXCHMASCVale && + mConditions.isXCHMAMCVale && + mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXAMAVale && + mConditions.isXCHMAMCVale && + mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMin && + mConditions.isXCHMASCUnderMin && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear) + // + || + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXCHMALCVale && + mConditions.isXCHMALCTrendsUp && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMAMCFastOverSlow && + mConditions.isXTSCurrentUnderFarest) + // + || + // + (mConditions.isXAMAVale && + mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXCHMASCVale && + mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMin && + mConditions.isXTMStartBearish && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXLHPriceCrossedUnderSignal) + // + ) + // + ) + // + || + // + // XOBDLH Long ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + // Check if SC Fast Under Slow ... + ((mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) && + ( + // + ((mConditions.isXTMVale && + mConditions.isXAMAVale && + mConditions.isXCHMAMCVale) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXTDSignalVale && + mConditions.isXTDBullishVale) + // + || + // + (mConditions.isXCHMASCVale && + mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsDown) + // + ) + // + ) + // + || + // + (mConditions.isXTMVale && + mConditions.isXAMAVale && + mConditions.isXCHMASCVale && + mConditions.isXCHMAMCVale && + mConditions.isXCHMALCVale) + // + || + // + ((mConditions.isXCHMAMCVale && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXCHMAMCFastUnderSlow) && + (mConditions.isXCHMALCVale && + mConditions.isXCHMALCTrendsUp && + mConditions.isXCHMALCFastUnderSlow)) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XOBDLH Long ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Long ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Long ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Long ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XOBDLH Long ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Long ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Long ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Long ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XOBDLH Short Signal Checking ... +bool XAU5XOBDLHHasShortSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXOBDLHEnableSignaller || + !xAU5MXOBDLHAllowShortSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XOBDLHHasShortConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XOBDLH Short ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Short ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCPeak && + mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTSCurrentMax && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentOverFarest) + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMAMCPeak && + mConditions.isXTSCurrentMax && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTSCurrentCrossedOverNearest && + mConditions.isXTSCurrentCrossedOverMediest) + // + ) + // + ) + // + || + // + // XOBDLH Short ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Short ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XOBDLH Short ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Short ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Short ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Short ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XOBDLH Short ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Short ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + ((mConditions.isXCHMAMCPeak && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXCHMAMCFastOverSlow) && + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsUp && + mConditions.isXCHMALCFastOverSlow)) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTSCurrentMax && + mConditions.isXCHMASCOverMax && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverMediest) + // + || + // + (mConditions.isXCHLHSameHHs && + mConditions.isXCHMASCOverMax && + mConditions.isXLHLLIncreased && + mConditions.isXTMStartBullish && + mConditions.isXTDBullOverBear && + mConditions.isXAMAStartBullish && + mConditions.isXCHMASCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMASCFastUnderSlow && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverMediest && + mConditions.isXLHPriceCrossedOverSignal) + // + || + // + ((mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear) && + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMALCTrendsUp && + mConditions.isXCHMASCFastOverSlow && + mConditions.isXCHMALCFastOverSlow && + mConditions.isXTSCurrentOverFarest) + // + || + // + (mConditions.isXCHMASCPeak && + mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax && + mConditions.isXTDBearishVale && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastUnderSlow && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentOverMediest) + // + || + // + ((mConditions.isXTSCurrentMin && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTSCurrentUnderMediest) && + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsUp && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXLHHighAttachedHH && + mConditions.isXCHMASCFastOverSlow && + mConditions.isXCHMALCFastOverSlow && + mConditions.isXCHMAMCFastUnderSlow) + // + ) + // + ) + // + ) + // + ) + // + || + // + ((mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMALCPeak && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentOverFarest && + mConditions.isXCHMALCFastOverSlow) && + ( + // + (mConditions.isXCHMASCOverMax && + mConditions.isXCHMALCTrendsUp && + mConditions.isXLHHighAttachedHH) + // + || + // + (mConditions.isXCHMASCPeak && + mConditions.isXCHMAMCPeak && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMASCFastOverSlow && + mConditions.isXCHMAMCFastOverSlow && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XOBDLH Short ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Short ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (mConditions.isXTMNeutural && + mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCPeak && + mConditions.isXAMANeutural && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXCHMALCTrendsUp && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverMediest) + // + || + // + ((mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTDBullOverBear) && + (mConditions.isXTSAllSame && + mConditions.isXCHMASCPeak && + mConditions.isXCHMALCVale && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMASCTrendsUp && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMASCFastOverSlow && + mConditions.isXCHMALCFastUnderSlow)) + // + || + // + ((mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMASCPeak) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMASCTrendsUp && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMASCFastOverSlow && + mConditions.isXTSCurrentOverFarest && + mConditions.isXCHMALCFastUnderSlow) + // + || + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCPeak && + mConditions.isXCHLHSameHHs && + mConditions.isXTSCurrentMin && + mConditions.isXLHHHIncreased && + mConditions.isXTDBullOverBear && + mConditions.isXCHMASCTrendsUp && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXTDSignalOverBear && + mConditions.isXCHMASCFastOverSlow && + mConditions.isXCHMAMCFastOverSlow && + mConditions.isXCHMALCFastOverSlow) + // + ) + // + ) + // + || + // + ((mConditions.isXCHMAMCPeak && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame) && + ( + // + ((mConditions.isXCHMALCPeak && + mConditions.isXTDSignalVale && + mConditions.isXTDBullishVale && + mConditions.isXCHMASCOverMax && + mConditions.isXTDSignalUnderBear) && + ( + // + (mConditions.isXCHMAMCTrendsUp && + mConditions.isXCHMALCTrendsUp && + mConditions.isXTSCurrentOverFarest) + // + || + // + (mConditions.isXTSCurrentMin && + mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastOverSlow) + // + || + // + (mConditions.isXTSCurrentMin && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXCHMALCTrendsUp) + // + ) + // + ) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMASCPeak && + mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCPeak && + mConditions.isXCHMASCTrendsUp && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXCHMALCTrendsUp) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXLHHHIncreased && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentOverMediest) + // + || + // + ((mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMASCPeak) && + ( + // + (mConditions.isXTSAllSame && + mConditions.isXCHMALCVale && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMASCTrendsUp && + mConditions.isXCHMALCTrendsDown && + mConditions.isXTDSignalUnderBear) + // + || + // + ((mConditions.isXCHMALCTrendsDown && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverMediest) && + ( + // + (mConditions.isXCHMASCOverMax && + mConditions.isXTDBullOverBear) + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXTDBearishVale && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXCHMASCTrendsDown) + // + ) + // + ) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXTDSignalVale && + mConditions.isXTDBullishVale && + mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverNearest) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XOBDLH Short ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Short ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Short ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XOBDLH Short ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XCHMACC Long Signal Checking ... +bool XAU5XCHMACCHasLongSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXCHMACCEnableSignaller || + !xAU5MXCHMACCAllowLongSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XCHMACCHasLongConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMACC Long ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMACC Long ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMACC Long ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow) && + ( + // + (mConditions.isXAMANeutural && + mConditions.isXTSCurrentMax && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTDSignalUnderBear) + // + || + // + (mConditions.isXAMANeutural && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTDBullCrossedOverBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMACC Long ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMACC Long ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow) && + ( + // + (mConditions.isXTMNeutural && + mConditions.isXTSCurrentMax && + mConditions.isXAMAStartBullish && + mConditions.isXTDSignalUnderBear && + mConditions.isXTDBullCrossedOverBear) + // + || + // + ((mConditions.isXTMBullish && + mConditions.isXAMABullish) && + ( + // + (mConditions.isXTSCurrentMax && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + || + // + ((mConditions.isXTMNeutural && + mConditions.isXAMANeutural) && + ( + // + (mConditions.isXCHMASCOverMin && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTDSignalCrossedOverBear) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMACC Long ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMACC Long ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMACC Long ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMACC Long ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTSCurrentCrossedUnderNearest && + mConditions.isXRSICrossedOverLongExit) + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXCHMASCOverMax && + mConditions.isXTDBullUnderBear && + mConditions.isXCHMASCTrendsDown && + mConditions.isXTDSignalUnderBear) + // + || + // + ((mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow) && + ( + // + mConditions.isXCHMALCPeak + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTSCurrentMax && + mConditions.isXCHMASCOverMax && + mConditions.isXTDSignalUnderBear && + mConditions.isXTDBullCrossedOverBear) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMax && + mConditions.isXCHMASCOverMax && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMACC Long ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + ((mConditions.isXTDBearishVale && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear) && + ( + // + (mConditions.isXTSAllSame && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMAMCTrendsDown) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMAMCTrendsDown) + // + ) + // + ) + // + || + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow) && + ( + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXCHLHSameHHs && + mConditions.isXTSCurrentMax && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMACC Long ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastOverSlow) + // + || + // + (mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow) && + ( + // + (mConditions.isXTSCurrentMax && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalUnderBear) + // + ) + // + ) + // + || + // + ((mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow) && + ( + // + mConditions.isXCHLHMCLCHHSame + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXTDSignalUnderBear && + mConditions.isXTDBullCrossedOverBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMACC Long ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + ((mConditions.isXTMBullish && + mConditions.isXAMABullish) && + ( + // + mConditions.isXRSICrossedOverLongExit + // + || + // + (mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow) + // + || + // + (mConditions.isXCHLHSameHHs && + mConditions.isXTSCurrentMax && + mConditions.isXTDBullUnderBear && + mConditions.isXLHHighAttachedHH && + mConditions.isXTDSignalUnderBear) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXTDBearishVale && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMACC Long ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMACC Long ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMACC Long ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMACC Long ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XCHMACC Short Signal Checking ... +bool XAU5XCHMACCHasShortSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXCHMACCEnableSignaller || + !xAU5MXCHMACCAllowShortSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XCHMACCHasShortConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMACC Short ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMin && + mConditions.isXTMStartBearish && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXCHMASCUnderMin && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMin && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXCHMASCUnderMin && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + ((mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastUnderSlow) && + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMABullish && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXTSCurrentCrossedUnderNearest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMACC Short ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMACC Short ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + ((mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastUnderSlow) && + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMACC Short ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow) && + ( + // + (mConditions.isXTDSignalVale && + mConditions.isXTSCurrentMin && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXTSCurrentCrossedUnderNearest) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMACC Short ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXCHMASCUnderMin && + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTDBullOverBear && + mConditions.isXTSCurrentOverNearest) + // + || + // + ((mConditions.isXCHMAMCVale && + !mConditions.isXCHMAMCTrendsUp && + !mConditions.isXCHMAMCTrendsDown) && + ( + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) + // + || + // + (mConditions.isXTSCurrentMin && + mConditions.isXTMStartBearish && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXAMAStartBearish && + mConditions.isXTDSignalUnderBear && + mConditions.isXLHPriceCrossedUnderSignal) + // + || + // + ((mConditions.isXTMBearish && + mConditions.isXAMABearish) && + ( + // + (mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest && + mConditions.isXTDBullCrossedUnderBear && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + (mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + (mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXLHLLIncreased && + mConditions.isXCHMALCTrendsDown && + mConditions.isXTSCurrentOverFarest && + mConditions.isXCHMALCFastUnderSlow) + // + || + // + (mConditions.isXTSCurrentMin && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTMStartBearish && + mConditions.isXAMAStartBearish && + mConditions.isXTDBullUnderBear && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMAMCFastUnderSlow) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMin && + mConditions.isXTDBearishVale && + mConditions.isXLHLLIncreased && + mConditions.isXTDBullUnderBear && + mConditions.isXCHMALCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + ((mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastUnderSlow) && + ( + // + (mConditions.isXTSCurrentMin && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDBullCrossedUnderBear) + // + ) + // + ) + // + || + // + (((mConditions.isXTSCurrentOverNearest || + mConditions.isXTSCurrentCrossedOverNearest) && + (mConditions.isXTSCurrentOverMediest || + mConditions.isXTSCurrentCrossedOverMediest)) && + ( + // + (mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHLHMCLCLLSame) + // + ) + // + ) + // + ) + // + ) + // + || + // + ((mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastUnderSlow) && + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalUnderBear) + // + || + // + (mConditions.isXAMABullish && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHLHMCLCLLSame) + // + || + // + ((mConditions.isXAMANeutural || + mConditions.isXAMAEndBullish) && + (mConditions.isXTMStartBearish) && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXLHPriceCrossedUnderSignal) + // + ) + // + ) + // + || + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow) && + ( + // + ((mConditions.isXCHLHMCLCHHSame && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentCrossedOverNearest) && + ( + // + mConditions.isXAMANeutural + // + || + // + (mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + ((mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastUnderSlow) && + ( + // + (mConditions.isXTSCurrentMin && + mConditions.isXLHHHDecreased && + mConditions.isXTDSignalUnderBear && + mConditions.isXTDBullCrossedUnderBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + || + // + // XCHMACC Short ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXTDBullOverBear && + (mConditions.isXTSCurrentOverNearest || + mConditions.isXTSCurrentCrossedOverNearest)) + // + ) + // + ) + // + || + // + // XCHMACC Short ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + ((mConditions.isXTMBearish && + mConditions.isXAMABearish) && + ( + // + (mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXCHMASCUnderMin) + // + || + // + ((mConditions.isXCHLHSCMCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear) && + ( + // + (mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderMediest) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMin && + mConditions.isXLHLowAttachedLL && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + (mConditions.isXCHLHSameLLs && + mConditions.isXTSCurrentMin && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow) + // + || + // + (mConditions.isXCHLHSameLLs && + mConditions.isXTSCurrentMin && + mConditions.isXLHLowAttachedLL && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTSCurrentUnderMediest && + mConditions.isXRSICrossedUnderShortExit) + // + ) + // + ) + // + || + // + (mConditions.isXTSCurrentMin && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXCHMASCUnderMin && + mConditions.isXLHLowAttachedLL && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTSCurrentUnderMediest && + mConditions.isXTDBullCrossedUnderBear && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + (mConditions.isXCHLHSameLLs && + mConditions.isXTSCurrentMin && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHMASCUnderMin && + mConditions.isXLHLowAttachedLL && + mConditions.isXTDBullUnderBear && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXTSCurrentCrossedUnderFarest && + mConditions.isXTSCurrentCrossedUnderNearest && + mConditions.isXTSCurrentCrossedUnderMediest) + // + ) + // + ) + // + || + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow) && + ( + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXLHPriceCrossedUnderSignal) + // + || + // + ((mConditions.isXTSCurrentOverNearest || + mConditions.isXTSCurrentCrossedOverNearest) && + ( + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear) + // + ) + // + ) + // + || + // + (mConditions.isXCHMASCUnderMin && + ( + // + (mConditions.isXTMVale && + mConditions.isXAMAVale && + mConditions.isXTSCurrentMin && + mConditions.isXLHLowAttachedLL && + mConditions.isXRSICrossedUnderShortExit) + // + || + // + ((mConditions.isXTSCurrentOverNearest || + mConditions.isXTSCurrentCrossedOverNearest) && + ( + // + ((mConditions.isXTMBearish && + mConditions.isXAMABearish) && + ( + // + ((mConditions.isXCHLHMCLCHHSame) && + ( + // + (mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverFarest) + // + || + // + (mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXFICrossedOverZero) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMACC Short ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (mConditions.isXCHMASCUnderMin && + ( + // + ((mConditions.isXTMBearish && + mConditions.isXAMABearish) && + ( + // + mConditions.isXRSICrossedUnderShortExit + // + || + // + (mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalUnderBear) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastUnderSlow) + // + || + // + (mConditions.isXTDBullOverBear && + (mConditions.isXTSCurrentOverMediest || + mConditions.isXTSCurrentCrossedOverMediest)) + // + || + // + (mConditions.isXCHLHSameLLs && + mConditions.isXTSCurrentMin && + mConditions.isXLHLowAttachedLL && + mConditions.isXTDBullCrossedUnderBear && + mConditions.isXTSCurrentCrossedUnderNearest && + mConditions.isXTSCurrentCrossedUnderMediest) + // + ) + // + ) + // + || + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow) && + ( + // + (mConditions.isXCHLHSameLLs && + mConditions.isXTSCurrentMin && + mConditions.isXLHLowAttachedLL && + mConditions.isXCHMASCCrossedUnderMin) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMACC Short ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow) && + ( + // + ((mConditions.isXTMBearish && + mConditions.isXAMABearish) && + ( + // + ((mConditions.isXTDSignalUnderBear && + mConditions.isXTDBullCrossedUnderBear) && + ( + // + mConditions.isXTSCurrentOverFarest + // + || + // + (mConditions.isXTSCurrentMin && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + (mConditions.isXAMABullish && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentCrossedUnderNearest && + mConditions.isXTSCurrentCrossedUnderMediest) + // + || + // + (mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMACC Short ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMACC Short ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow) && + ( + // + (mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentCrossedUnderFarest && + mConditions.isXTSCurrentCrossedUnderNearest && + mConditions.isXTSCurrentCrossedUnderMediest) + // + || + // + (mConditions.isXTMBearish && + mConditions.isXAMABullish && + mConditions.isXTDBullOverBear && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentCrossedUnderNearest && + mConditions.isXTSCurrentCrossedUnderMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMACC Short ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMACC Short ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMACC Short ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMACC Short ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMACC Short ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XCHMAMN Long Signal Checking ... +bool XAU5XCHMAMNHasLongSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXCHMAMNEnableSignaller || + !xAU5MXCHMAMNAllowLongSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XCHMAMNHasLongConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMN Long ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow) && + ( + // + (mConditions.isXTSCurrentMax && + mConditions.isXLHLLIncreased && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMAMN Long ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + (((mConditions.isXTMNeutural && + mConditions.isXAMANeutural) || + (mConditions.isXTMEndBullish && + mConditions.isXAMAEndBullish)) && + ( + // + (mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + || + // + ((mConditions.isXCHMALCVale && + mConditions.isXCHMALCTrendsUp && + mConditions.isXCHMALCFastUnderSlow) && + ( + // + ((mConditions.isXTMNeutural && + mConditions.isXAMANeutural) && + ( + // + (mConditions.isXTSCurrentMax && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDSignalOverBear && + mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastOverSlow) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMAMN Long ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTSCurrentMax && + mConditions.isXLHLLIncreased && + mConditions.isXTDSignalUnderBear) + // + || + // + (mConditions.isXCHMALCVale && + mConditions.isXAMANeutural && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXCHMALCFastUnderSlow && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXCHMASCFastCrossedUnderSlow) + // + || + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow) && + ( + // + (mConditions.isXTSCurrentMax && + mConditions.isXTDSignalUnderBear && + mConditions.isXTDBullCrossedOverBear) + // + ) + // + ) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXTMStartBullish && + mConditions.isXAMAStartBullish && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXCHMALCFastUnderSlow && + mConditions.isXCHMASCFastCrossedUnderSlow && + mConditions.isXTSCurrentCrossedOverFarest && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + || + // + // XCHMAMN Long ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMN Long ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow) && + ( + // + (mConditions.isXAMAVale && + mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax && + mConditions.isXLHLLIncreased && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentCrossedOverFarest && + mConditions.isXTSCurrentCrossedOverMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMAMN Long ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Long ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Long ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMN Long ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXCHMASCPeak && + mConditions.isXCHMAMCVale && + mConditions.isXTSCurrentMax && + mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXLHPriceCrossedOverSignal) + // + || + // + ((mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow) && + ( + // + (mConditions.isXTSCurrentMax && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXTDSignalCrossedOverBear && + mConditions.isXTSCurrentCrossedOverNearest && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXLHLLIncreased && + mConditions.isXTMStartBullish && + mConditions.isXAMAStartBullish && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentCrossedOverFarest) + // + ) + // + ) + // + || + // + (((mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastOverSlow) && + (mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow)) && + ( + // + (mConditions.isXTDSignalVale && + mConditions.isXTSCurrentMax && + mConditions.isXTDBullishVale && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDSignalOverBear) + // + ) + // + ) + // + || + // + (((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow) && + (mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastUnderSlow)) && + ( + // + (mConditions.isXTSCurrentMax && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTMStartBullish && + mConditions.isXAMAStartBullish && + mConditions.isXLHPriceCrossedOverSignal && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + ((mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax && + mConditions.isXTDSignalUnderBear) && + ( + // + mConditions.isXLHPriceCrossedOverSignal + // + || + // + (mConditions.isXTDBullUnderBear && + mConditions.isXCHMASCFastCrossedOverSlow) + // + ) + // + ) + // + || + // + ((mConditions.isXLHPriceCrossedOverSignal && + mConditions.isXTSCurrentCrossedOverNearest) && + ( + // + (mConditions.isXCHMASCPeak && + mConditions.isXTSCurrentMax && + mConditions.isXCHMASCTrendsDown) + // + || + // + (mConditions.isXCHMASCPeak && + mConditions.isXCHMAMCVale && + mConditions.isXCHMALCVale && + mConditions.isXTSCurrentMax) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTMStartBullish && + mConditions.isXAMAStartBullish) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMAMN Long ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTSCurrentUnderMediest && + mConditions.isXTSCurrentCrossedUnderNearest && + mConditions.isXTSCurrentCrossedUnderMediest) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXCHMALCFastUnderSlow && + mConditions.isXLHPriceCrossedOverSignal && + mConditions.isXTSCurrentCrossedOverFarest && + mConditions.isXTSCurrentCrossedOverMediest) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXTMStartBullish && + mConditions.isXAMAStartBullish && + mConditions.isXTDBullUnderBear && + mConditions.isXLHHighAttachedHH && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentOverMediest && + mConditions.isXLHPriceCrossedOverSignal) + // + || + // + ((mConditions.isXCHMASCPeak && + mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastOverSlow) && + ( + // + (mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow) + // + || + // + (mConditions.isXTMBullish && + mConditions.isXAMABullish && + mConditions.isXTSCurrentMax && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentCrossedOverFarest) + // + ) + // + ) + // + || + // + ((mConditions.isXCHMALCVale && + mConditions.isXCHMALCTrendsUp && + mConditions.isXCHMALCFastUnderSlow) && + ( + // + (mConditions.isXCHMASCPeak && + mConditions.isXCHMAMCVale && + mConditions.isXTSCurrentMax && + mConditions.isXLHHHDecreased && + mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastUnderSlow && + mConditions.isXCHMAMCFastUnderSlow) + // + ) + // + ) + // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXTMStartBullish && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDBullOverBear && + mConditions.isXAMAStartBullish && + mConditions.isXTDSignalOverBear && + mConditions.isXCHMAMCFastUnderSlow && + mConditions.isXCHMALCFastUnderSlow && + mConditions.isXLHPriceCrossedOverSignal && + mConditions.isXTSCurrentCrossedOverMediest) + // + ) + // + ) + // + || + // + // XCHMAMN Long ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (mConditions.isXCHMASCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMASCFastOverSlow && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderMediest && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + ((mConditions.isXCHMALCVale && + mConditions.isXCHMALCTrendsUp && + mConditions.isXCHMALCFastUnderSlow) && + ( + // + (mConditions.isXTSCurrentMax && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMAMCFastUnderSlow) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMAMN Long ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMN Long ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Long ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Long ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Long ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XCHMAMN Short Signal Checking ... +bool XAU5XCHMAMNHasShortSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXCHMAMNEnableSignaller || + !xAU5MXCHMAMNAllowShortSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XCHMAMNHasShortConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMN Short ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Short ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Short ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Short ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMN Short ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXCHMASCVale && + mConditions.isXCHMASCTrendsDown) + // + || + // + (mConditions.isXCHMAMCVale && + mConditions.isXCHMAMCTrendsDown) + // + || + // + (mConditions.isXCHMASCFastOverSlow && + mConditions.isXCHMALCFastOverSlow && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentCrossedOverNearest) + // + || + // + (mConditions.isXTMVale && + mConditions.isXAMAVale && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMALCFastOverSlow && + mConditions.isXTSCurrentOverNearest) + // + ) + // + ) + // + || + // + // XCHMAMN Short ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Short ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Short ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMN Short ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Short ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Short ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Short ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMN Short ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Short ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Short ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMN Short ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XCHMAMX Long Signal Checking ... +bool XAU5XCHMAMXHasLongSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXCHMAMXEnableSignaller || + !xAU5MXCHMAMXAllowLongSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XCHMAMXHasLongConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMX Long ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + ((mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow) && + ( + // + (mConditions.isXTMEndBullish && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentUnderNearest && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + (mConditions.isXTSCurrentMin && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderFarest) + // + || + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCPeak && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow) + // + ) + // + ) + // + || + // + ((mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastUnderSlow) && + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTSCurrentMax && + mConditions.isXTDBearishVale && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear && + mConditions.isXCHMASCFastCrossedOverSlow && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMAMX Long ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMX Long ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow) && + (mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow)) && + ( + // + (mConditions.isXTSCurrentMin && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTMStartBearish && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXAMAStartBearish && + mConditions.isXTDBullUnderBear && + mConditions.isXLHLowAttachedLL && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMASCFastCrossedUnderSlow) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMAMX Long ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMX Long ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + ((mConditions.isXCHMAMCPeak && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow) && + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTDBearishVale && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentUnderFarest && + mConditions.isXTSCurrentUnderMediest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMAMX Long ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMX Long ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastOverSlow) && + ( + // + ( + mConditions.isXCHMAMCPeak && + ( + // + ((mConditions.isXTMBullish && + mConditions.isXAMABullish) && + ( + // + (mConditions.isXTSCurrentMax && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear) + // + ) + // + ) + // + ) + // + ) + // + )) + // + ) + // + ) + // + || + // + // XCHMAMX Long ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMX Long ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMX Long ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMX Long ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMX Long ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMX Long ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMX Long ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMX Long ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMX Long ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// XCHMAMX Short Signal Checking ... +bool XAU5XCHMAMXHasShortSignal() +{ + // + bool result = false; + + // + // Validate Args ... + if (!xAU5MXCHMAMXEnableSignaller || + !xAU5MXCHMAMXAllowShortSignals) + { + return result; + } + + // + // Retrieve Market Condition ... + XMarketConditions mConditions = xAU5Provider.GetLastMarketCondition(); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + xAU5Provider.XCHMAMXHasShortConditions() + // + && + // + // Exceptions: + // there some commonly Exceptions which makes our choice incorrect, + // here we are combined knownly Exceptions ... + !( + // + // for Exception we used XLH Conditions as follow ... + // + // Check Conditions if Price In Signal Range ... + (mConditions.isXLHPriceInSignalRange && + // + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMX Short ... + // PriceInSignalRange ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXAMANeutural && + mConditions.isXTSCurrentMin && + (!mConditions.isXCHMAMCTrendsUp && + !mConditions.isXCHMAMCTrendsDown) && + mConditions.isXCHMAMCFastOverSlow) + // + || + // + (((mConditions.isXTMNeutural && + mConditions.isXTMEndBearish) && + (mConditions.isXAMANeutural && + mConditions.isXAMAEndBearish)) && + ( + // + (mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear) + // + ) + // + ) + // + || + // + (((mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastUnderSlow) && + (mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastUnderSlow)) && + ( + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMAMCTrendsUp) + // + ) + // + ) + // + || + // + (((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow) && + (mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow)) && + ( + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXTSCurrentMin && + mConditions.isXTDSignalUnderBear && + mConditions.isXTDBullCrossedUnderBear && + mConditions.isXTSCurrentCrossedUnderNearest) + // + ) + // + ) + // + || + // + (mConditions.isXCHMASCVale && + mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMASCFastOverSlow && + mConditions.isXCHMAMCFastOverSlow && + mConditions.isXCHMALCFastOverSlow) + // + || + // + (mConditions.isXTSCurrentMin && + mConditions.isXTMStartBearish && + mConditions.isXAMAStartBearish && + mConditions.isXTDBullUnderBear && + mConditions.isXCHMALCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMALCFastUnderSlow) + // + ) + // + ) + // + || + // + // XCHMAMX Short ... + // PriceInSignalRange ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + (mConditions.isXTMNeutural && + mConditions.isXAMANeutural && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow) + // + ) + // + ) + // + || + // + // XCHMAMX Short ... + // PriceInSignalRange ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (mConditions.isXTSCurrentMin && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTMStartBearish && + mConditions.isXLHLowAttachedLL && + mConditions.isXAMAStartBearish && + mConditions.isXCHMASCFastCrossedUnderSlow) + // + || + // + ((mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastUnderSlow) && + ( + // + (mConditions.isXCHLHSameHHs && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXTMStartBearish && + mConditions.isXAMAStartBearish && + mConditions.isXTDSignalOverBear && + mConditions.isXCHMAMCFastOverSlow) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMAMX Short ... + // PriceInSignalRange ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + ((mConditions.isXTMNeutural && + mConditions.isXAMANeutural) && + ( + // + ((mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXLHLowAttachedLL) && + ( + // + mConditions.isXTDSignalCrossedUnderBear + // + || + // + (mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentCrossedUnderFarest) + // + ) + // + ) + // + ) + // + ) + // + || + // + (mConditions.isXTMNeutural && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXAMAStartBearish && + mConditions.isXLHLowAttachedLL && + mConditions.isXTDSignalOverBear && + mConditions.isXTSCurrentCrossedUnderFarest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Under Signal ... + ( + // + ((mConditions.isXLHPriceUnderSignal || + mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMX Short ... + // PriceUnderSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + ((mConditions.isXTDBullOverBear && + mConditions.isXTDSignalOverBear) && + ( + // + (mConditions.isXLHHHDecreased && + mConditions.isXTSCurrentOverFarest && + mConditions.isXLHPriceCrossedUnderSignal) + // + ) + // + ) + // + || + // + ((mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear) && + ( + // + ((mConditions.isXTMStartBearish && + mConditions.isXAMAStartBearish) && + ( + // + (mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentCrossedUnderNearest) + // + || + // + (((mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastUnderSlow) && + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow)) && + ( + // + mConditions.isXTSCurrentOverFarest + // + ) + // + ) + // + ) + // + ) + // + || + // + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMin && + mConditions.isXCHLHMCLCHHSame && + mConditions.isXTMStartBearish && + mConditions.isXAMAStartBearish && + mConditions.isXTSCurrentCrossedUnderNearest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMAMX Short ... + // PriceUnderSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + // + ((mConditions.isXTMNeutural && + mConditions.isXAMANeutural) && + ( + // + mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCPeak && + mConditions.isXTDBullOverBear && + mConditions.isXTSCurrentOverFarest + // + ) + // + ) + // + || + // + ((mConditions.isXTMBearish && + mConditions.isXAMABearish) && + ( + // + (mConditions.isXTDBullOverBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMAMX Short ... + // PriceUnderSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + ((mConditions.isXCHMALCPeak && + mConditions.isXCHMALCTrendsUp && + mConditions.isXCHMALCFastOverSlow) && + ( + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXTDBullOverBear && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXLHLowAttachedLL && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + || + // + (mConditions.isXTMBearish && + mConditions.isXAMABearish && + mConditions.isXCHMALCPeak && + mConditions.isXTSCurrentMin && + mConditions.isXCHLHSCMCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXLHLowAttachedLL && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMASCFastCrossedUnderSlow && + mConditions.isXTSCurrentCrossedUnderNearest) + // + ) + // + ) + // + || + // + // XCHMAMX Short ... + // PriceUnderSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is Over Signal ... + ( + // + ((mConditions.isXLHPriceOverSignal || + mConditions.isXLHPriceCrossedOverSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMX Short ... + // PriceOverSignal ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + // + ((mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow) && + ( + // + (mConditions.isXTDBullOverBear && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTDSignalCrossedUnderBear) + // + ) + // + ) + // + || + // + ((mConditions.isXCHMAMCPeak && + mConditions.isXCHMAMCTrendsUp && + mConditions.isXCHMAMCFastOverSlow) && + ( + // + ((mConditions.isXTMNeutural && + mConditions.isXAMANeutural) && + ( + // + (mConditions.isXTSCurrentMin && + mConditions.isXTDBullOverBear) + // + || + // + (mConditions.isXTDBullOverBear && + mConditions.isXTSCurrentOverFarest) + // + ) + // + ) + // + ) + // + ) + // + || + // + (((mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastUnderSlow) && + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow)) && + ( + // + (mConditions.isXAMABullish && + mConditions.isXTSCurrentMin && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentCrossedUnderFarest && + mConditions.isXTSCurrentCrossedUnderMediest) + // + || + // + (mConditions.isXCHMALCPeak && + mConditions.isXAMABullish && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentCrossedUnderMediest) + // + ) + // + ) + // + || + // + ((mConditions.isXCHMALCTrendsDown && + mConditions.isXCHMALCFastOverSlow) && + ( + // + (mConditions.isXAMANeutural && + mConditions.isXTSCurrentMin && + mConditions.isXAMAEndBullish && + mConditions.isXTDBullOverBear && + mConditions.isXTMStartBearish && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXCHMASCCrossedUnderMax && + mConditions.isXTDSignalCrossedUnderBear && + mConditions.isXCHMASCFastCrossedUnderSlow) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMAMX Short ... + // PriceOverSignal ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMX Short ... + // PriceOverSignal ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + // + (((mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMASCFastUnderSlow) && + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMAMCFastUnderSlow)) && + ( + // + (mConditions.isXTMBearish && + mConditions.isXAMABullish && + mConditions.isXTDBullOverBear && + mConditions.isXTSCurrentOverFarest && + mConditions.isXTSCurrentOverNearest && + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + ) + // + ) + // + ) + // + || + // + // XCHMAMX Short ... + // PriceOverSignal ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + || + // + // Check Conditions if Price is not has clear state ... + ( + // + ((!mConditions.isXLHPriceOverSignal && + !mConditions.isXLHPriceUnderSignal && + !mConditions.isXLHPriceInSignalRange && + !mConditions.isXLHPriceCrossedOverSignal && + !mConditions.isXLHPriceCrossedUnderSignal) && + ( + // + // Next Step is to Check LL and HH Same Style ... + // + // XCHMAMX Short ... + // PriceFree ... + // Check if Both LL and HH Same In Length ... + ((mConditions.isXLHLLSameInLength && + mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMX Short ... + // PriceFree ... + // Check If LL Same In Length ... + ((mConditions.isXLHLLSameInLength && + !mConditions.isXLHHHSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMX Short ... + // PriceFree ... + // Check If HH is Same In Length ... + ((mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + || + // + // XCHMAMX Short ... + // PriceFree ... + // Not Same LL or HH in Lenght ... + ((!mConditions.isXLHHHSameInLength && + !mConditions.isXLHLLSameInLength) && + // + ( + false) + // + ) + // + ) + // + ) + // + ) + // + ) + // + ; + + // + return result; +} + +// +// END Signal Providers ... +// diff --git a/Projects/XAU5/Providers/x-saherelm.xau5.provider.indicators.lib.mq5 b/Projects/XAU5/Providers/x-saherelm.xau5.provider.indicators.lib.mq5 index 775d6e71..ff0fafb0 100644 --- a/Projects/XAU5/Providers/x-saherelm.xau5.provider.indicators.lib.mq5 +++ b/Projects/XAU5/Providers/x-saherelm.xau5.provider.indicators.lib.mq5 @@ -7165,6 +7165,13 @@ bool XAU5XTSFIHasShortSignal() mConditions.isXAMABearish && mConditions.isXTSCurrentOverMediest) && ( + // + (mConditions.isXTDBullUnderBear && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMAMCFastUnderSlow) + // + || // (mConditions.isXCHMALCVale && mConditions.isXCHLHMCLCLLSame && @@ -7651,19 +7658,19 @@ bool XAU5XTSFIHasShortSignal() ( // ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) + mConditions.isXAMANeutural) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) // ) // @@ -10612,6 +10619,16 @@ bool XAU5XCHMAMNHasLongSignal() mConditions.isXTSCurrentCrossedOverNearest && mConditions.isXTSCurrentCrossedOverMediest) // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXLHLLIncreased && + mConditions.isXTMStartBullish && + mConditions.isXAMAStartBullish && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentCrossedOverFarest) + // ) // ) diff --git a/Providers/x-saherelm.xau5.provider.indicators.lib.mq5 b/Providers/x-saherelm.xau5.provider.indicators.lib.mq5 index 775d6e71..ff0fafb0 100644 --- a/Providers/x-saherelm.xau5.provider.indicators.lib.mq5 +++ b/Providers/x-saherelm.xau5.provider.indicators.lib.mq5 @@ -7165,6 +7165,13 @@ bool XAU5XTSFIHasShortSignal() mConditions.isXAMABearish && mConditions.isXTSCurrentOverMediest) && ( + // + (mConditions.isXTDBullUnderBear && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXTDSignalUnderBear && + mConditions.isXCHMAMCFastUnderSlow) + // + || // (mConditions.isXCHMALCVale && mConditions.isXCHLHMCLCLLSame && @@ -7651,19 +7658,19 @@ bool XAU5XTSFIHasShortSignal() ( // ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) + mConditions.isXAMANeutural) && + ( + // + (mConditions.isXCHMALCVale && + mConditions.isXCHLHSCMCHHSame && + mConditions.isXCHLHMCLCLLSame && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentOverMediest) + // + ) + // + ) // ) // @@ -10612,6 +10619,16 @@ bool XAU5XCHMAMNHasLongSignal() mConditions.isXTSCurrentCrossedOverNearest && mConditions.isXTSCurrentCrossedOverMediest) // + || + // + (mConditions.isXTSCurrentMax && + mConditions.isXLHLLIncreased && + mConditions.isXTMStartBullish && + mConditions.isXAMAStartBullish && + mConditions.isXTDBullUnderBear && + mConditions.isXTDSignalUnderBear && + mConditions.isXTSCurrentCrossedOverFarest) + // ) // )