From 670ca1eac2d911b139f2f38903c6b8ff13f781ed Mon Sep 17 00:00:00 2001 From: Hadi Khazaee Asl Date: Tue, 28 May 2024 08:01:50 +0330 Subject: [PATCH] cleanup ... --- Classes/x-saherelm.x121.provider.class.mq5 | 5321 +- Classes/x-saherelm.x121.xea.class.mq5 | 64 +- Classes/x-saherelm.x5.provider.class.mq5 | 95417 ------------------- Classes/x-saherelm.x5.xea.class.mq5 | 308 - Experts/x-test.x121ea.mq5 | 24 +- Experts/x-test.x5121ea.mq5 | 1169 - Experts/x-test.x5ea.mq5 | 252 - Indicators/x-saherelm.xchlh.mq5 | 96 +- Indicators/x-saherelm.xchma.mq5 | 96 +- Indicators/x-saherelm.xfi.mq5 | 28 +- Indicators/x-saherelm.xrsi.mq5 | 30 +- Indicators/x-saherelm.xtd.mq5 | 57 +- Indicators/x-saherelm.xts.mq5 | 66 +- 13 files changed, 5533 insertions(+), 97395 deletions(-) delete mode 100644 Classes/x-saherelm.x5.provider.class.mq5 delete mode 100644 Classes/x-saherelm.x5.xea.class.mq5 delete mode 100644 Experts/x-test.x5121ea.mq5 delete mode 100644 Experts/x-test.x5ea.mq5 diff --git a/Classes/x-saherelm.x121.provider.class.mq5 b/Classes/x-saherelm.x121.provider.class.mq5 index ed580122..76ab39b3 100644 --- a/Classes/x-saherelm.x121.provider.class.mq5 +++ b/Classes/x-saherelm.x121.provider.class.mq5 @@ -33,6 +33,16 @@ #include "../Helpers/x-saherelm.xstr.helper.mq5" #include "../Helpers/x-saherelm.xche.helper.mq5" #include "../Helpers/x-saherelm.xosc.helper.mq5" +#include "../Helpers/x-saherelm.xtm.helper.mq5" +#include "../Helpers/x-saherelm.xama.helper.mq5" +#include "../Helpers/x-saherelm.xlh.helper.mq5" +#include "../Helpers/x-saherelm.xtd.helper.mq5" +#include "../Helpers/x-saherelm.xfi.helper.mq5" +#include "../Helpers/x-saherelm.xts.helper.mq5" +#include "../Helpers/x-saherelm.xrsi.helper.mq5" +#include "../Helpers/x-saherelm.xobd.helper.mq5" +#include "../Helpers/x-saherelm.xchlh.helper.mq5" +#include "../Helpers/x-saherelm.xchma.helper.mq5" // #include "../Classes/x-saherelm.xprovider.class.mq5" @@ -46,14 +56,23 @@ enum ENUM_X121_SIGNAL_PROVIDERS { // - X121NONE, - X121XSP, + PROVIDER_NONE, + XSP, XTEST, X786, X121, X110, X92, X128, + // + XTD, + XTAM, + XSI, + XTSFI, + XOBDLH, + XCHMACC, + XCHMAMN, + XCHMAMX, }; // @@ -109,6 +128,18 @@ public: XDONInputs donInputs; XOSCInputs oscInputs; + // + XTSInputs tsInputs; + XTMInputs tmInputs; + XLHInputs lhInputs; + XTDInputs tdInputs; + XFIInputs fiInputs; + XOBDInputs obdInputs; + XAMAInputs amaInputs; + XRSIInputs rsiInputs; + XCHLHInputs chlhInputs; + XCHMAInputs chmaInputs; + // X121MCycleInputs cMarketInputs; // Curent Market Inputs X121MCycleInputs sMarketInputs; // Short Market Inputs @@ -185,6 +216,48 @@ public: ichInputs.Default(); } + // + if (!tsInputs.IsValid()) + { + tsInputs.Default(); + } + if (!tmInputs.IsValid()) + { + tmInputs.Default(); + } + if (!lhInputs.IsValid()) + { + lhInputs.Default(); + } + if (!tdInputs.IsValid()) + { + tdInputs.Default(); + } + if (!fiInputs.IsValid()) + { + fiInputs.Default(); + } + if (!obdInputs.IsValid()) + { + obdInputs.Default(); + } + if (!amaInputs.IsValid()) + { + amaInputs.Default(); + } + if (!rsiInputs.IsValid()) + { + rsiInputs.Default(); + } + if (!chlhInputs.IsValid()) + { + chlhInputs.Default(); + } + if (!chmaInputs.IsValid()) + { + chmaInputs.Default(); + } + // // Initialize Market Inputs ... @@ -356,6 +429,17 @@ public: oscInputs.IsValid() && ichInputs.IsValid() && // + tsInputs.IsValid() && + tmInputs.IsValid() && + lhInputs.IsValid() && + tdInputs.IsValid() && + fiInputs.IsValid() && + obdInputs.IsValid() && + amaInputs.IsValid() && + rsiInputs.IsValid() && + chlhInputs.IsValid() && + chmaInputs.IsValid() && + // cMarketInputs.IsValid() && sMarketInputs.IsValid() && mMarketInputs.IsValid() && @@ -410,6 +494,17 @@ public: oscInputs.Clean(); ichInputs.Clean(); // + tsInputs.Clean(); + tmInputs.Clean(); + lhInputs.Clean(); + tdInputs.Clean(); + fiInputs.Clean(); + obdInputs.Clean(); + amaInputs.Clean(); + rsiInputs.Clean(); + chlhInputs.Clean(); + chmaInputs.Clean(); + // cMarketInputs.Clean(); sMarketInputs.Clean(); mMarketInputs.Clean(); @@ -458,6 +553,16 @@ public: donInputs.Default(); oscInputs.Default(); ichInputs.Default(); + tsInputs.Default(); + tmInputs.Default(); + lhInputs.Default(); + tdInputs.Default(); + fiInputs.Default(); + obdInputs.Default(); + amaInputs.Default(); + rsiInputs.Default(); + chlhInputs.Default(); + chmaInputs.Default(); cMarketInputs.Default(); sMarketInputs.Default(); mMarketInputs.Default(); @@ -472,6 +577,21 @@ public: // int result = 0; + // + result = MathMax(lhInputs.Max(), tmInputs.Max()); + + // + result = MathMax(result, tsInputs.Max()); + result = MathMax(result, ctInputs.Max()); + result = MathMax(result, ccInputs.Max()); + result = MathMax(result, tdInputs.Max()); + result = MathMax(result, fiInputs.Max()); + result = MathMax(result, obdInputs.Max()); + result = MathMax(result, amaInputs.Max()); + result = MathMax(result, rsiInputs.Max()); + result = MathMax(result, chlhInputs.Max()); + result = MathMax(result, chmaInputs.Max()); + // return result; } @@ -538,6 +658,234 @@ class X121MarketConditions : public XSCBaseProviderMarketConditions // // Public ... public: + // + + // + // XTS ... + double tsCurrents[]; + double tsNearests[]; + double tsMediests[]; + double tsFarests[]; + + // + // XFI ... + double fis[]; + + // + // XTD ... + double tdBullishs[]; + double tdBearishs[]; + double tdSignals[]; + + // + // XLH ... + double lhHhs[]; + double lhLls[]; + double lhSignals[]; + + // + // XTM ... + double tms[]; + + // + // XAMA ... + double amas[]; + + // + // XOBD ... + double obds[]; + + // + // XRSI ... + double rsis[]; + + // + // XCHMA ... + double chmaScFasts[]; + double chmaScSlows[]; + double chmaMcFasts[]; + double chmaMcSlows[]; + double chmaLcFasts[]; + double chmaLcSlows[]; + double chmaHotStates[]; + + // + // XCHLH ... + double chlhScHHs[]; + double chlhScLLs[]; + double chlhMcHHs[]; + double chlhMcLLs[]; + double chlhLcHHs[]; + double chlhLcLLs[]; + double chlhHotStates[]; + + // + // Conditional Variables ... + + // + // XTM ... + bool isXTMPeak; + bool isXTMVale; + bool isXTMBullish; + bool isXTMBearish; + bool isXTMNeutural; + bool isXTMEndBullish; + bool isXTMEndBearish; + bool isXTMStartBullish; + bool isXTMStartBearish; + bool isXTMEndBullishByNeutural; + bool isXTMEndBearishByNeutural; + bool isXTMStartBullishAfterNeutural; + bool isXTMStartBearishAfterNeutural; + + // + // XAMA ... + bool isXAMAPeak; + bool isXAMAVale; + bool isXAMABullish; + bool isXAMABearish; + bool isXAMANeutural; + bool isXAMAEndBullish; + bool isXAMAEndBearish; + bool isXAMAStartBullish; + bool isXAMAStartBearish; + bool isXAMAEndBullishByNeutural; + bool isXAMAEndBearishByNeutural; + bool isXAMAStartBullishAfterNeutural; + bool isXAMAStartBearishAfterNeutural; + + // + // XLH ... + bool isXLHHHIncreased; + bool isXLHHHDecreased; + bool isXLHLLIncreased; + bool isXLHLLDecreased; + bool isXLHLowAttachedLL; + bool isXLHHighAttachedHH; + bool isXLHHHSameInLength; + bool isXLHLLSameInLength; + bool isXLHPriceOverSignal; + bool isXLHPriceUnderSignal; + bool isXLHPriceInSignalRange; + bool isXLHPriceCrossedOverSignal; + bool isXLHPriceCrossedUnderSignal; + + // + // XTD ... + bool isXTDSignalPeak; + bool isXTDSignalVale; + bool isXTDBullishPeak; + bool isXTDBullishVale; + bool isXTDBearishPeak; + bool isXTDBearishVale; + bool isXTDBullOverBear; + bool isXTDBullUnderBear; + bool isXTDSignalOverBear; + bool isXTDSignalUnderBear; + bool isXTDBullCrossedOverBear; + bool isXTDBullCrossedUnderBear; + bool isXTDSignalCrossedOverBear; + bool isXTDSignalCrossedUnderBear; + + // + // XFI ... + bool isXFIPeak; + bool isXFIVale; + bool isXFICrossedOverZero; + bool isXFIOverZero; + bool isXFICrossedUnderZero; + bool isXFIUnderZero; + + // + // XTS ... + bool isXTSAllSame; + bool isXTSCurrentMin; + bool isXTSCurrentMax; + bool isXTSCurrentOverFarest; + bool isXTSCurrentOverNearest; + bool isXTSCurrentOverMediest; + bool isXTSCurrentUnderFarest; + bool isXTSCurrentUnderNearest; + bool isXTSCurrentUnderMediest; + bool isXTSCurrentCrossedOverFarest; + bool isXTSCurrentCrossedOverNearest; + bool isXTSCurrentCrossedOverMediest; + bool isXTSCurrentCrossedUnderFarest; + bool isXTSCurrentCrossedUnderNearest; + bool isXTSCurrentCrossedUnderMediest; + + // + // XRSI ... + bool isXRSIPeak; + bool isXRSIVale; + bool isXRSICrossedOverLongExit; + bool isXRSICrossedOverLongEntry; + bool isXRSICrossedUnderShortExit; + bool isXRSICrossedUnderShortEntry; + + // + // XOBD ... + bool isXOBDSwingLow; + bool isXOBDSwingHigh; + + // + // XCHLH ... + // + bool isXCHLHSameHHs; + bool isXCHLHSameLLs; + // + bool isXCHLHSCMCHHSame; + bool isXCHLHSCMCLLSame; + // + bool isXCHLHSCLCHHSame; + bool isXCHLHSCLCLLSame; + // + bool isXCHLHMCLCHHSame; + bool isXCHLHMCLCLLSame; + // + bool isXCHLHMCOnTopOfLC; + bool isXCHLHMCInBottomOfLC; + + // + // XCHMA ... + // + bool isXCHMASCOverMax; + bool isXCHMASCOverMin; + bool isXCHMASCUnderMax; + bool isXCHMASCUnderMin; + // + bool isXCHMASCCrossedOverMax; + bool isXCHMASCCrossedUnderMax; + bool isXCHMASCCrossedOverMin; + bool isXCHMASCCrossedUnderMin; + // + bool isXCHMASCPeak; + bool isXCHMASCVale; + bool isXCHMASCTrendsUp; + bool isXCHMASCTrendsDown; + bool isXCHMASCFastOverSlow; + bool isXCHMASCFastUnderSlow; + bool isXCHMASCFastCrossedOverSlow; + bool isXCHMASCFastCrossedUnderSlow; + // + bool isXCHMAMCPeak; + bool isXCHMAMCVale; + bool isXCHMAMCTrendsUp; + bool isXCHMAMCTrendsDown; + bool isXCHMAMCFastOverSlow; + bool isXCHMAMCFastUnderSlow; + bool isXCHMAMCFastCrossedOverSlow; + bool isXCHMAMCFastCrossedUnderSlow; + // + bool isXCHMALCPeak; + bool isXCHMALCVale; + bool isXCHMALCTrendsUp; + bool isXCHMALCTrendsDown; + bool isXCHMALCFastOverSlow; + bool isXCHMALCFastUnderSlow; + bool isXCHMALCFastCrossedOverSlow; + bool isXCHMALCFastCrossedUnderSlow; + // X121MCycleConditions cMarketConditions; // Current Market Conditions X121MCycleConditions sMarketConditions; // Short Market Conditions @@ -581,6 +929,980 @@ public: double hMarketMultiplier = 1.8 // Hind Market Score Multiplier ) { + // + double bullScore = 0; + double bearScore = 0; + + // + // XTM ... + + // + if (isXTMPeak) + { + // + bullScore--; + bearScore++; + } + + // + if (isXTMVale) + { + // + bullScore++; + bearScore--; + } + + // + if (isXTMBullish) + { + bullScore++; + } + + // + if (isXTMBearish) + { + bearScore++; + } + + // + if (isXTMNeutural) + { + } + + // + if (isXTMEndBullish) + { + bearScore++; + } + + // + if (isXTMEndBearish) + { + bullScore++; + } + + // + if (isXTMStartBullish) + { + bullScore++; + } + + // + if (isXTMStartBearish) + { + bearScore++; + } + + // + if (isXTMEndBullishByNeutural) + { + bearScore++; + } + + // + if (isXTMEndBearishByNeutural) + { + bullScore++; + } + + // + if (isXTMStartBullishAfterNeutural) + { + bullScore++; + } + + // + if (isXTMStartBearishAfterNeutural) + { + bearScore++; + } + + // + // XAMA ... + + // + if (isXAMAPeak) + { + // + bullScore--; + bearScore++; + } + + // + if (isXAMAVale) + { + // + bullScore++; + bearScore--; + } + + // + if (isXAMABullish) + { + bullScore++; + } + + // + if (isXAMABearish) + { + bearScore++; + } + + // + if (isXAMANeutural) + { + } + + // + if (isXAMAEndBullish) + { + bearScore++; + } + + // + if (isXAMAEndBearish) + { + bullScore++; + } + + // + if (isXAMAStartBullish) + { + bullScore++; + } + + // + if (isXAMAStartBearish) + { + bearScore++; + } + + // + if (isXAMAEndBullishByNeutural) + { + bearScore++; + } + + // + if (isXAMAEndBearishByNeutural) + { + bullScore++; + } + + // + if (isXAMAStartBullishAfterNeutural) + { + bullScore++; + } + + // + if (isXAMAStartBearishAfterNeutural) + { + bearScore++; + } + + // + // XLH ... + + // + if (isXLHHHIncreased) + { + // + bullScore--; + bearScore++; + } + + // + if (isXLHHHDecreased) + { + // + bullScore++; + bearScore--; + } + + // + if (isXLHLLIncreased) + { + // + bullScore++; + bearScore--; + } + + // + if (isXLHLLDecreased) + { + // + bullScore--; + bearScore++; + } + + // + if (isXLHLowAttachedLL) + { + // + bullScore++; + bearScore--; + } + + // + if (isXLHHighAttachedHH) + { + // + bullScore--; + bearScore++; + } + + // + if (isXLHHHSameInLength) + { + } + + // + if (isXLHLLSameInLength) + { + } + + // + if (isXLHPriceOverSignal) + { + bullScore++; + } + + // + if (isXLHPriceUnderSignal) + { + bearScore++; + } + + // + if (isXLHPriceInSignalRange) + { + } + + // + if (isXLHPriceCrossedOverSignal) + { + // + bullScore++; + bearScore--; + } + + // + if (isXLHPriceCrossedUnderSignal) + { + // + bullScore--; + bearScore++; + } + + // + // XTD ... + + // + if (isXTDSignalPeak) + { + // + bullScore--; + bearScore++; + } + + // + if (isXTDSignalVale) + { + // + bullScore++; + bearScore--; + } + + // + if (isXTDBullishPeak) + { + // + bullScore--; + bearScore++; + } + + // + if (isXTDBullishVale) + { + // + bullScore++; + bearScore--; + } + + // + if (isXTDBearishPeak) + { + // + bullScore++; + bearScore--; + } + + // + if (isXTDBearishVale) + { + // + bullScore--; + bearScore++; + } + + // + if (isXTDBullOverBear) + { + bullScore++; + } + + // + if (isXTDBullUnderBear) + { + bearScore++; + } + + // + if (isXTDSignalOverBear) + { + bullScore++; + } + + // + if (isXTDSignalUnderBear) + { + bearScore++; + } + + // + if (isXTDBullCrossedOverBear) + { + // + bullScore++; + bearScore--; + } + + // + if (isXTDBullCrossedUnderBear) + { + // + bullScore--; + bearScore++; + } + + // + if (isXTDSignalCrossedOverBear) + { + // + bullScore++; + bearScore--; + } + + // + if (isXTDSignalCrossedUnderBear) + { + // + bullScore--; + bearScore++; + } + + // + // XFI ... + + // + if (isXFIPeak) + { + // + bullScore--; + bearScore++; + } + + // + if (isXFIVale) + { + // + bullScore++; + bearScore--; + } + + // + if (isXFICrossedOverZero) + { + // + bullScore++; + bearScore--; + } + + // + if (isXFIOverZero) + { + bullScore++; + } + + // + if (isXFICrossedUnderZero) + { + // + bullScore--; + bearScore++; + } + + // + if (isXFIUnderZero) + { + bearScore++; + } + + // + // XTS ... + + // + if (isXTSAllSame) + { + } + + // + if (isXTSCurrentMin) + { + // + bullScore++; + bearScore--; + } + + // + if (isXTSCurrentMax) + { + // + bullScore--; + bearScore++; + } + + // + if (isXTSCurrentOverFarest) + { + bullScore--; + } + + // + if (isXTSCurrentOverNearest) + { + bullScore--; + } + + // + if (isXTSCurrentOverMediest) + { + bullScore--; + } + + // + if (isXTSCurrentUnderFarest) + { + bearScore--; + } + + // + if (isXTSCurrentUnderNearest) + { + bearScore--; + } + + // + if (isXTSCurrentUnderMediest) + { + bearScore--; + } + + // + if (isXTSCurrentCrossedOverFarest) + { + // + bullScore++; + bearScore--; + } + + // + if (isXTSCurrentCrossedOverNearest) + { + // + bullScore++; + bearScore--; + } + + // + if (isXTSCurrentCrossedOverMediest) + { + // + bullScore++; + bearScore--; + } + + // + if (isXTSCurrentCrossedUnderFarest) + { + // + bullScore--; + bearScore++; + } + + // + if (isXTSCurrentCrossedUnderNearest) + { + // + bullScore--; + bearScore++; + } + + // + if (isXTSCurrentCrossedUnderMediest) + { + // + bullScore--; + bearScore++; + } + + // + // XSI ... + + // + if (isXRSIPeak) + { + // + bullScore--; + bearScore++; + } + + // + if (isXRSIVale) + { + // + bullScore++; + bearScore--; + } + + // + if (isXRSICrossedOverLongExit) + { + // + bullScore--; + bearScore++; + } + + // + if (isXRSICrossedOverLongEntry) + { + // + bullScore++; + bearScore--; + } + + // + if (isXRSICrossedUnderShortExit) + { + // + bullScore++; + bearScore--; + } + + // + if (isXRSICrossedUnderShortEntry) + { + // + bullScore--; + bearScore++; + } + + // + // XOBD ... + + // + if (isXOBDSwingLow) + { + bullScore++; + } + + // + if (isXOBDSwingHigh) + { + bearScore++; + } + + // + // XCHLH ... + + // + if (isXCHLHSameHHs) + { + bearScore++; + } + + // + if (isXCHLHSameLLs) + { + bullScore++; + } + + // + if (isXCHLHSCMCHHSame) + { + bearScore++; + } + + // + if (isXCHLHSCMCLLSame) + { + bullScore++; + } + + // + if (isXCHLHSCLCHHSame) + { + bearScore++; + } + + // + if (isXCHLHSCLCLLSame) + { + bullScore++; + } + + // + if (isXCHLHMCLCHHSame) + { + bearScore++; + } + + // + if (isXCHLHMCLCLLSame) + { + bullScore++; + } + + // + if (isXCHLHMCOnTopOfLC) + { + } + + // + if (isXCHLHMCInBottomOfLC) + { + } + + // + // XCHMA ... + + // + if (isXCHMASCOverMax) + { + // + bullScore--; + bearScore++; + } + + // + if (isXCHMASCOverMin) + { + // + bullScore++; + bearScore--; + } + + // + if (isXCHMASCUnderMax) + { + // + bullScore--; + bearScore++; + } + + // + if (isXCHMASCUnderMin) + { + // + bullScore++; + bearScore--; + } + + // + if (isXCHMASCCrossedOverMax) + { + // + bearScore--; + bearScore++; + } + + // + if (isXCHMASCCrossedUnderMax) + { + // + bullScore--; + bearScore++; + } + + // + if (isXCHMASCCrossedOverMin) + { + // + bullScore++; + bearScore--; + } + + // + if (isXCHMASCCrossedUnderMin) + { + // + bullScore++; + bearScore--; + } + + // + if (isXCHMASCPeak) + { + // + bullScore--; + bearScore++; + } + + // + if (isXCHMASCVale) + { + // + bullScore++; + bearScore--; + } + + // + if (isXCHMASCTrendsUp) + { + // + if (isXCHMASCFastOverSlow) + { + // + bullScore++; + bearScore--; + } + + // + if (isXCHMASCFastUnderSlow) + { + // + bullScore--; + bearScore++; + } + } + + // + if (isXCHMASCTrendsDown) + { + // + if (isXCHMASCFastOverSlow) + { + // + bullScore--; + bearScore++; + } + + // + if (isXCHMASCFastUnderSlow) + { + // + bullScore++; + bearScore--; + } + } + + // + if (isXCHMASCFastOverSlow) + { + bearScore++; + } + + // + if (isXCHMASCFastUnderSlow) + { + bearScore++; + } + + // + if (isXCHMASCFastCrossedOverSlow) + { + // + bullScore++; + bearScore--; + } + + // + if (isXCHMASCFastCrossedUnderSlow) + { + // + bullScore--; + bearScore++; + } + + // + if (isXCHMAMCPeak) + { + // + bullScore--; + bearScore++; + } + + // + if (isXCHMAMCVale) + { + // + bullScore++; + bearScore--; + } + + // + if (isXCHMAMCTrendsUp) + { + // + if (isXCHMAMCFastOverSlow) + { + // + bullScore++; + bearScore--; + } + + // + if (isXCHMAMCFastUnderSlow) + { + // + bullScore--; + bearScore++; + } + } + + // + if (isXCHMAMCTrendsDown) + { + // + if (isXCHMAMCFastOverSlow) + { + // + bullScore--; + bearScore++; + } + + // + if (isXCHMAMCFastUnderSlow) + { + // + bullScore++; + bearScore--; + } + } + + // + if (isXCHMAMCFastOverSlow) + { + bullScore++; + } + + // + if (isXCHMAMCFastUnderSlow) + { + bearScore++; + } + + // + if (isXCHMAMCFastCrossedOverSlow) + { + // + bullScore++; + bearScore--; + } + + // + if (isXCHMAMCFastCrossedUnderSlow) + { + // + bullScore--; + bearScore++; + } + + // + if (isXCHMALCPeak) + { + // + bullScore--; + bearScore++; + } + + // + if (isXCHMALCVale) + { + // + bullScore++; + bearScore--; + } + + // + if (isXCHMALCTrendsUp) + { + // + if (isXCHMALCFastOverSlow) + { + // + bullScore++; + bearScore--; + } + + // + if (isXCHMALCFastUnderSlow) + { + // + bullScore--; + bearScore++; + } + } + + // + if (isXCHMALCTrendsDown) + { + // + if (isXCHMALCFastOverSlow) + { + // + bullScore--; + bearScore++; + } + + // + if (isXCHMALCFastUnderSlow) + { + // + bullScore++; + bearScore--; + } + } + + // + if (isXCHMALCFastOverSlow) + { + bullScore++; + } + + // + if (isXCHMALCFastUnderSlow) + { + bearScore++; + } + + // + if (isXCHMALCFastCrossedOverSlow) + { + // + bullScore++; + bearScore--; + } + + // + if (isXCHMALCFastCrossedUnderSlow) + { + // + bullScore--; + bearScore++; + } + // // Current Market ... double cMarketBullScore = 0; @@ -637,6 +1959,7 @@ public: // bullishScore = // + bullScore + cMarketBullScore + sMarketBullScore + mMarketBullScore + @@ -648,6 +1971,7 @@ public: // bearishScore = // + bearScore + cMarketBearScore + sMarketBearScore + mMarketBearScore + @@ -714,6 +2038,223 @@ public: // ; + // + // XOBD ... + string obdStr = + // + ToString("isXOBDSwingLow", isXOBDSwingLow, ignoreFalseConditions) + + ToString("isXOBDSwingHigh", isXOBDSwingHigh, ignoreFalseConditions) + + "" + // + ; + obdStr = SetLabel("XOBD: ", obdStr, separator); + + // + // ToString("", , ignoreFalseConditions) + + + // + // XFI ... + string fiStr = + // + ToString("isXFIPeak", isXFIPeak, ignoreFalseConditions) + + ToString("isXFIVale", isXFIVale, ignoreFalseConditions) + + ToString("isXFICrossedOverZero", isXFICrossedOverZero, ignoreFalseConditions) + + ToString("isXFIOverZero", isXFIOverZero, ignoreFalseConditions) + + ToString("isXFICrossedUnderZero", isXFICrossedUnderZero, ignoreFalseConditions) + + ToString("isXFIUnderZero", isXFIUnderZero, ignoreFalseConditions) + + "" + // + ; + fiStr = SetLabel("XFI: ", fiStr, separator); + + // + // XRSI ... + string rsiStr = + // + ToString("isXRSIPeak", isXRSIPeak, ignoreFalseConditions) + + ToString("isXRSIVale", isXRSIVale, ignoreFalseConditions) + + ToString("isXRSICrossedOverLongExit", isXRSICrossedOverLongExit, ignoreFalseConditions) + + ToString("isXRSICrossedOverLongEntry", isXRSICrossedOverLongEntry, ignoreFalseConditions) + + ToString("isXRSICrossedUnderShortExit", isXRSICrossedUnderShortExit, ignoreFalseConditions) + + ToString("isXRSICrossedUnderShortEntry", isXRSICrossedUnderShortEntry, ignoreFalseConditions) + + "" + // + ; + rsiStr = SetLabel("XRSI: ", rsiStr, separator); + + // + // XTM ... + string tmStr = + // + ToString("isXTMPeak", isXTMPeak, ignoreFalseConditions) + + ToString("isXTMVale", isXTMVale, ignoreFalseConditions) + + ToString("isXTMBullish", isXTMBullish, ignoreFalseConditions) + + ToString("isXTMBearish", isXTMBearish, ignoreFalseConditions) + + ToString("isXTMNeutural", isXTMNeutural, ignoreFalseConditions) + + ToString("isXTMEndBullish", isXTMEndBullish, ignoreFalseConditions) + + ToString("isXTMEndBearish", isXTMEndBearish, ignoreFalseConditions) + + ToString("isXTMStartBullish", isXTMStartBullish, ignoreFalseConditions) + + ToString("isXTMStartBearish", isXTMStartBearish, ignoreFalseConditions) + + ToString("isXTMEndBullishByNeutural", isXTMEndBullishByNeutural, ignoreFalseConditions) + + ToString("isXTMEndBearishByNeutural", isXTMEndBearishByNeutural, ignoreFalseConditions) + + ToString("isXTMStartBullishAfterNeutural", isXTMStartBullishAfterNeutural, ignoreFalseConditions) + + ToString("isXTMStartBearishAfterNeutural", isXTMStartBearishAfterNeutural, ignoreFalseConditions) + + "" + // + ; + tmStr = SetLabel("XTM: ", tmStr, separator); + + // + // XAMA ... + string amaStr = + // + ToString("isXAMAPeak", isXAMAPeak, ignoreFalseConditions) + + ToString("isXAMAVale", isXAMAVale, ignoreFalseConditions) + + ToString("isXAMABullish", isXAMABullish, ignoreFalseConditions) + + ToString("isXAMABearish", isXAMABearish, ignoreFalseConditions) + + ToString("isXAMANeutural", isXAMANeutural, ignoreFalseConditions) + + ToString("isXAMAEndBullish", isXAMAEndBullish, ignoreFalseConditions) + + ToString("isXAMAEndBearish", isXAMAEndBearish, ignoreFalseConditions) + + ToString("isXAMAStartBullish", isXAMAStartBullish, ignoreFalseConditions) + + ToString("isXAMAStartBearish", isXAMAStartBearish, ignoreFalseConditions) + + ToString("isXAMAEndBullishByNeutural", isXAMAEndBullishByNeutural, ignoreFalseConditions) + + ToString("isXAMAEndBearishByNeutural", isXAMAEndBearishByNeutural, ignoreFalseConditions) + + ToString("isXAMAStartBullishAfterNeutural", isXAMAStartBullishAfterNeutural, ignoreFalseConditions) + + ToString("isXAMAStartBearishAfterNeutural", isXAMAStartBearishAfterNeutural, ignoreFalseConditions) + + "" + // + ; + amaStr = SetLabel("XAMA: ", amaStr, separator); + + // + // XLH ... + string lhStr = + // + ToString("isXLHHHIncreased", isXLHHHIncreased, ignoreFalseConditions) + + ToString("isXLHHHDecreased", isXLHHHDecreased, ignoreFalseConditions) + + ToString("isXLHLLIncreased", isXLHLLIncreased, ignoreFalseConditions) + + ToString("isXLHLLDecreased", isXLHLLDecreased, ignoreFalseConditions) + + ToString("isXLHLowAttachedLL", isXLHLowAttachedLL, ignoreFalseConditions) + + ToString("isXLHHighAttachedHH", isXLHHighAttachedHH, ignoreFalseConditions) + + ToString("isXLHHHSameInLength", isXLHHHSameInLength, ignoreFalseConditions) + + ToString("isXLHLLSameInLength", isXLHLLSameInLength, ignoreFalseConditions) + + ToString("isXLHPriceOverSignal", isXLHPriceOverSignal, ignoreFalseConditions) + + ToString("isXLHPriceUnderSignal", isXLHPriceUnderSignal, ignoreFalseConditions) + + ToString("isXLHPriceInSignalRange", isXLHPriceInSignalRange, ignoreFalseConditions) + + ToString("isXLHPriceCrossedOverSignal", isXLHPriceCrossedOverSignal, ignoreFalseConditions) + + ToString("isXLHPriceCrossedUnderSignal", isXLHPriceCrossedUnderSignal, ignoreFalseConditions) + + "" + // + ; + lhStr = SetLabel("XLH: ", lhStr, separator); + + // + // XTD ... + string tdStr = + // + ToString("isXTDSignalPeak", isXTDSignalPeak, ignoreFalseConditions) + + ToString("isXTDSignalVale", isXTDSignalVale, ignoreFalseConditions) + + ToString("isXTDBullishPeak", isXTDBullishPeak, ignoreFalseConditions) + + ToString("isXTDBullishVale", isXTDBullishVale, ignoreFalseConditions) + + ToString("isXTDBearishPeak", isXTDBearishPeak, ignoreFalseConditions) + + ToString("isXTDBearishVale", isXTDBearishVale, ignoreFalseConditions) + + ToString("isXTDBullOverBear", isXTDBullOverBear, ignoreFalseConditions) + + ToString("isXTDBullUnderBear", isXTDBullUnderBear, ignoreFalseConditions) + + ToString("isXTDSignalOverBear", isXTDSignalOverBear, ignoreFalseConditions) + + ToString("isXTDSignalUnderBear", isXTDSignalUnderBear, ignoreFalseConditions) + + ToString("isXTDBullCrossedOverBear", isXTDBullCrossedOverBear, ignoreFalseConditions) + + ToString("isXTDBullCrossedUnderBear", isXTDBullCrossedUnderBear, ignoreFalseConditions) + + ToString("isXTDSignalCrossedOverBear", isXTDSignalCrossedOverBear, ignoreFalseConditions) + + ToString("isXTDSignalCrossedUnderBear", isXTDSignalCrossedUnderBear, ignoreFalseConditions) + + "" + // + ; + tdStr = SetLabel("XTD: ", tdStr, separator); + + // + // XTS ... + string tsStr = + // + ToString("isXTSAllSame", isXTSAllSame, ignoreFalseConditions) + + ToString("isXTSCurrentMin", isXTSCurrentMin, ignoreFalseConditions) + + ToString("isXTSCurrentMax", isXTSCurrentMax, ignoreFalseConditions) + + ToString("isXTSCurrentOverFarest", isXTSCurrentOverFarest, ignoreFalseConditions) + + ToString("isXTSCurrentOverNearest", isXTSCurrentOverNearest, ignoreFalseConditions) + + ToString("isXTSCurrentOverMediest", isXTSCurrentOverMediest, ignoreFalseConditions) + + ToString("isXTSCurrentUnderFarest", isXTSCurrentUnderFarest, ignoreFalseConditions) + + ToString("isXTSCurrentUnderNearest", isXTSCurrentUnderNearest, ignoreFalseConditions) + + ToString("isXTSCurrentUnderMediest", isXTSCurrentUnderMediest, ignoreFalseConditions) + + ToString("isXTSCurrentCrossedOverFarest", isXTSCurrentCrossedOverFarest, ignoreFalseConditions) + + ToString("isXTSCurrentCrossedOverNearest", isXTSCurrentCrossedOverNearest, ignoreFalseConditions) + + ToString("isXTSCurrentCrossedOverMediest", isXTSCurrentCrossedOverMediest, ignoreFalseConditions) + + ToString("isXTSCurrentCrossedUnderFarest", isXTSCurrentCrossedUnderFarest, ignoreFalseConditions) + + ToString("isXTSCurrentCrossedUnderNearest", isXTSCurrentCrossedUnderNearest, ignoreFalseConditions) + + ToString("isXTSCurrentCrossedUnderMediest", isXTSCurrentCrossedUnderMediest, ignoreFalseConditions) + + "" + // + ; + tsStr = SetLabel("XTS: ", tsStr, separator); + + // + // XCHLH ... + string chlhStr = + // + ToString("isXCHLHSameHHs", isXCHLHSameHHs, ignoreFalseConditions) + + ToString("isXCHLHSameLLs", isXCHLHSameLLs, ignoreFalseConditions) + + ToString("isXCHLHSCMCHHSame", isXCHLHSCMCHHSame, ignoreFalseConditions) + + ToString("isXCHLHSCMCLLSame", isXCHLHSCMCLLSame, ignoreFalseConditions) + + ToString("isXCHLHSCLCHHSame", isXCHLHSCLCHHSame, ignoreFalseConditions) + + ToString("isXCHLHSCLCLLSame", isXCHLHSCLCLLSame, ignoreFalseConditions) + + ToString("isXCHLHMCLCHHSame", isXCHLHMCLCHHSame, ignoreFalseConditions) + + ToString("isXCHLHMCLCLLSame", isXCHLHMCLCLLSame, ignoreFalseConditions) + + ToString("isXCHLHMCOnTopOfLC", isXCHLHMCOnTopOfLC, ignoreFalseConditions) + + ToString("isXCHLHMCInBottomOfLC", isXCHLHMCInBottomOfLC, ignoreFalseConditions) + + "" + // + ; + chlhStr = SetLabel("XCHLH: ", chlhStr, separator); + + // + // XCHMA ... + string chmaStr = + // + ToString("isXCHMASCOverMax", isXCHMASCOverMax, ignoreFalseConditions) + + ToString("isXCHMASCOverMin", isXCHMASCOverMin, ignoreFalseConditions) + + ToString("isXCHMASCUnderMax", isXCHMASCUnderMax, ignoreFalseConditions) + + ToString("isXCHMASCUnderMin", isXCHMASCUnderMin, ignoreFalseConditions) + + ToString("isXCHMASCCrossedOverMax", isXCHMASCCrossedOverMax, ignoreFalseConditions) + + ToString("isXCHMASCCrossedUnderMax", isXCHMASCCrossedUnderMax, ignoreFalseConditions) + + ToString("isXCHMASCCrossedOverMin", isXCHMASCCrossedOverMin, ignoreFalseConditions) + + ToString("isXCHMASCCrossedUnderMin", isXCHMASCCrossedUnderMin, ignoreFalseConditions) + + ToString("isXCHMASCPeak", isXCHMASCPeak, ignoreFalseConditions) + + ToString("isXCHMASCVale", isXCHMASCVale, ignoreFalseConditions) + + ToString("isXCHMASCTrendsUp", isXCHMASCTrendsUp, ignoreFalseConditions) + + ToString("isXCHMASCTrendsDown", isXCHMASCTrendsDown, ignoreFalseConditions) + + ToString("isXCHMASCFastOverSlow", isXCHMASCFastOverSlow, ignoreFalseConditions) + + ToString("isXCHMASCFastUnderSlow", isXCHMASCFastUnderSlow, ignoreFalseConditions) + + ToString("isXCHMASCFastCrossedOverSlow", isXCHMASCFastCrossedOverSlow, ignoreFalseConditions) + + ToString("isXCHMASCFastCrossedUnderSlow", isXCHMASCFastCrossedUnderSlow, ignoreFalseConditions) + + ToString("isXCHMAMCPeak", isXCHMAMCPeak, ignoreFalseConditions) + + ToString("isXCHMAMCVale", isXCHMAMCVale, ignoreFalseConditions) + + ToString("isXCHMAMCTrendsUp", isXCHMAMCTrendsUp, ignoreFalseConditions) + + ToString("isXCHMAMCTrendsDown", isXCHMAMCTrendsDown, ignoreFalseConditions) + + ToString("isXCHMAMCFastOverSlow", isXCHMAMCFastOverSlow, ignoreFalseConditions) + + ToString("isXCHMAMCFastUnderSlow", isXCHMAMCFastUnderSlow, ignoreFalseConditions) + + ToString("isXCHMAMCFastCrossedOverSlow", isXCHMAMCFastCrossedOverSlow, ignoreFalseConditions) + + ToString("isXCHMAMCFastCrossedUnderSlow", isXCHMAMCFastCrossedUnderSlow, ignoreFalseConditions) + + ToString("isXCHMALCPeak", isXCHMALCPeak, ignoreFalseConditions) + + ToString("isXCHMALCVale", isXCHMALCVale, ignoreFalseConditions) + + ToString("isXCHMALCTrendsUp", isXCHMALCTrendsUp, ignoreFalseConditions) + + ToString("isXCHMALCTrendsDown", isXCHMALCTrendsDown, ignoreFalseConditions) + + ToString("isXCHMALCFastOverSlow", isXCHMALCFastOverSlow, ignoreFalseConditions) + + ToString("isXCHMALCFastUnderSlow", isXCHMALCFastUnderSlow, ignoreFalseConditions) + + ToString("isXCHMALCFastCrossedOverSlow", isXCHMALCFastCrossedOverSlow, ignoreFalseConditions) + + ToString("isXCHMALCFastCrossedUnderSlow", isXCHMALCFastCrossedUnderSlow, ignoreFalseConditions) + + "" + // + ; + chmaStr = SetLabel("XCHMA: ", chmaStr, separator); + // string cMarketConditionsStr = cMarketConditions.GenerateSummary(onlySummary, cMarketMultiplier); string sMarketConditionsStr = sMarketConditions.GenerateSummary(onlySummary, sMarketMultiplier); @@ -729,7 +2270,17 @@ public: "-----------------------------" + separator + commonStr + (!onlySummary - ? cMarketConditionsStr + + ? obdStr + + fiStr + + rsiStr + + tmStr + + amaStr + + lhStr + + tdStr + + tsStr + + chlhStr + + chmaStr + + cMarketConditionsStr + sMarketConditionsStr + mMarketConditionsStr + lMarketConditionsStr + @@ -785,6 +2336,18 @@ public: XSCXCCHelper *ccHelper; // Candle Clear XSCXCTHelper *ctHelper; // Candle Timer + // + XSCXTSHelper *tsHelper; + XSCXFIHelper *fiHelper; + XSCXTDHelper *tdHelper; + XSCXLHHelper *lhHelper; + XSCXTMHelper *tmHelper; + XSCXOBDHelper *obdHelper; + XSCXRSIHelper *rsiHelper; + XSCXAMAHelper *amaHelper; + XSCXCHMAHelper *chmaHelper; + XSCXCHLHHelper *chlhHelper; + // XSCX121Market *cMarket; // Current Market XSCX121Market *sMarket; // Short Market @@ -805,6 +2368,18 @@ public: ccHelper = new XSCXCCHelper(); ctHelper = new XSCXCTHelper(); + // + tsHelper = new XSCXTSHelper(); + fiHelper = new XSCXFIHelper(); + tdHelper = new XSCXTDHelper(); + lhHelper = new XSCXLHHelper(); + tmHelper = new XSCXTMHelper(); + obdHelper = new XSCXOBDHelper(); + rsiHelper = new XSCXRSIHelper(); + amaHelper = new XSCXAMAHelper(); + chmaHelper = new XSCXCHMAHelper(); + chlhHelper = new XSCXCHLHHelper(); + // // Instantiate X121 Market Cycles Classes ... cMarket = new XSCX121Market(); @@ -869,6 +2444,18 @@ public: delete ccHelper; delete ctHelper; + // + delete tsHelper; + delete fiHelper; + delete tdHelper; + delete lhHelper; + delete tmHelper; + delete obdHelper; + delete rsiHelper; + delete amaHelper; + delete chmaHelper; + delete chlhHelper; + // delete cMarket; delete sMarket; @@ -933,6 +2520,136 @@ public: return result; } + // + result = tsHelper + .Init( + mSymbol, + mPeriod, + mInputs.tsInputs + // + ); + if (!result) + { + return result; + } + + // + result = fiHelper + .Init( + mSymbol, + mPeriod, + mInputs.fiInputs + // + ); + if (!result) + { + return result; + } + + // + result = tdHelper + .Init( + mSymbol, + mPeriod, + mInputs.tdInputs + // + ); + if (!result) + { + return result; + } + + // + result = lhHelper + .Init( + mSymbol, + mPeriod, + mInputs.lhInputs + // + ); + if (!result) + { + return result; + } + + // + result = tmHelper + .Init( + mSymbol, + mPeriod, + mInputs.tmInputs + // + ); + if (!result) + { + return result; + } + + // + result = obdHelper + .Init( + mSymbol, + mPeriod, + mInputs.obdInputs + // + ); + if (!result) + { + return result; + } + + // + result = rsiHelper + .Init( + mSymbol, + mPeriod, + mInputs.rsiInputs + // + ); + if (!result) + { + return result; + } + + // + result = amaHelper + .Init( + mSymbol, + mPeriod, + mInputs.amaInputs + // + ); + if (!result) + { + return result; + } + + // + result = chmaHelper + .Init( + mSymbol, + mPeriod, + mInputs.chmaInputs + // + ); + if (!result) + { + return result; + } + + // + result = chlhHelper + .Init( + mSymbol, + mPeriod, + mInputs.chlhInputs + // + ); + if (!result) + { + return result; + } + // // Initialize X121 Market Cycles ... @@ -1012,7 +2729,7 @@ public: ) { // - if (provider == X121NONE) + if (provider == PROVIDER_NONE) { return; } @@ -1021,8 +2738,8 @@ public: switch (provider) { // - case X121XSP: - mIsX121XSPSignalProviderEnable = state; + case XSP: + mIsXSPSignalProviderEnable = state; break; // @@ -1054,6 +2771,46 @@ public: case X128: mIsX128SignalProviderEnable = state; break; + + // + case XTD: + mIsXTDSignalProviderEnable = state; + break; + + // + case XTAM: + mIsXTAMSignalProviderEnable = state; + break; + + // + case XSI: + mIsXSISignalProviderEnable = state; + break; + + // + case XTSFI: + mIsXTSFISignalProviderEnable = state; + break; + + // + case XOBDLH: + mIsXOBDLHSignalProviderEnable = state; + break; + + // + case XCHMACC: + mIsXCHMACCSignalProviderEnable = state; + break; + + // + case XCHMAMN: + mIsXCHMAMNSignalProviderEnable = state; + break; + + // + case XCHMAMX: + mIsXCHMAMXSignalProviderEnable = state; + break; } } @@ -1209,6 +2966,43 @@ public: return result; } + // + // Validate Longs Use Common Conditions ... + + // + // if (hasLong) + // { + // // + // int pusher = 0; + // result = HasBaseLongConditions( + // mConditions, + // pusher // + // ); + + // // + // if (!result) + // { + // return result; + // } + // } + + // // + // if (hasShort) + // { + // // + // int pusher = 0; + // result = HasBaseShortConditions( + // mConditions, + // pusher // + // ); + + // // + // if (!result) + // { + // return result; + // } + // } + // // Prepare Signal ... @@ -1326,7 +3120,7 @@ public: // // Generate Support Signal for Specified Provider ... - if (result && provider == ToString(X121NONE)) + if (result && provider == ToString(PROVIDER_NONE)) { // double cKijunSen = cMarket.ich.GetKijunSen(0); @@ -2835,6 +4629,27 @@ private: // Store Market Conditions Scores ... void AddScores(X121MarketConditions &conditions) { + // + static datetime lasrScoreAdded = NULL; + ENUM_TIMEFRAMES mPeriod = GetPeriod(); + int seconds = PeriodSeconds(mPeriod); + datetime cTime = TimeCurrent(); + int dateDiff = (int)cTime - (int)lasrScoreAdded; + bool canDo = + // + lasrScoreAdded == NULL + ? true + : dateDiff >= seconds + // + ; + if (!canDo) + { + return; + } + + // + lasrScoreAdded = cTime; + // double bullishScore = 0; double bearishScore = 0; @@ -3017,13 +4832,21 @@ private: bool mIsShortEnable; // - bool mIsX121XSPSignalProviderEnable; + bool mIsXSPSignalProviderEnable; bool mIsX128SignalProviderEnable; bool mIsX92SignalProviderEnable; bool mIsX786SignalProviderEnable; bool mIsX121SignalProviderEnable; bool mIsX110SignalProviderEnable; bool mIsXTESTSignalProviderEnable; + bool mIsXTDSignalProviderEnable; + bool mIsXTAMSignalProviderEnable; + bool mIsXSISignalProviderEnable; + bool mIsXTSFISignalProviderEnable; + bool mIsXOBDLHSignalProviderEnable; + bool mIsXCHMACCSignalProviderEnable; + bool mIsXCHMAMNSignalProviderEnable; + bool mIsXCHMAMXSignalProviderEnable; // // @@ -3067,20 +4890,28 @@ private: signalPusher = 0; // - bool hasX121XSPSignal = false; + bool hasXSPSignal = false; bool hasXTESTSignal = false; bool hasX786Signal = false; bool hasX121Signal = false; bool hasX110Signal = false; bool hasX92Signal = false; bool hasX128Signal = false; + bool hasXTDSignal = false; + bool hasXTAMSignal = false; + bool hasXSISignal = false; + bool hasXTSFISignal = false; + bool hasXOBDLHSignal = false; + bool hasXCHMACCSignal = false; + bool hasXCHMAMNSignal = false; + bool hasXCHMAMXSignal = false; // // XPS ... - if (mIsX121XSPSignalProviderEnable) + if (mIsXSPSignalProviderEnable) { // - hasX121XSPSignal = X121XSPHasSpecifiedLongSignal( + hasXSPSignal = XSPHasSpecifiedLongSignal( mConditions, providedSL, providedTP, @@ -3088,12 +4919,12 @@ private: ); // - if (hasX121XSPSignal) + if (hasXSPSignal) { // if (!IsValid(provider)) { - provider = ToString(X121XSP); + provider = ToString(XSP); } // @@ -3257,10 +5088,218 @@ private: } } + // + // XTD ... + if (mIsXTDSignalProviderEnable) + { + // + hasXTDSignal = XTDHasSpecifiedLongSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXTDSignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XTD); + } + + // + signalPusher++; + } + } + + // + // XTAM ... + if (mIsXTAMSignalProviderEnable) + { + // + hasXTAMSignal = XTAMHasSpecifiedLongSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXTAMSignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XTAM); + } + + // + signalPusher++; + } + } + + // + // XSI ... + if (mIsXSISignalProviderEnable) + { + // + hasXSISignal = XSIHasSpecifiedLongSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXSISignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XSI); + } + + // + signalPusher++; + } + } + + // + // XTSFI ... + if (mIsXTSFISignalProviderEnable) + { + // + hasXTSFISignal = XTSFIHasSpecifiedLongSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXTSFISignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XTSFI); + } + + // + signalPusher++; + } + } + + // + // XOBDLH ... + if (mIsXOBDLHSignalProviderEnable) + { + // + hasXOBDLHSignal = XOBDLHHasSpecifiedLongSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXOBDLHSignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XOBDLH); + } + + // + signalPusher++; + } + } + + // + // XCHMACC ... + if (mIsXCHMACCSignalProviderEnable) + { + // + hasXCHMACCSignal = XCHMACCHasSpecifiedLongSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXCHMACCSignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XCHMACC); + } + + // + signalPusher++; + } + } + + // + // XCHMAMN ... + if (mIsXCHMAMNSignalProviderEnable) + { + // + hasXCHMAMNSignal = XCHMAMNHasSpecifiedLongSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXCHMAMNSignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XCHMAMN); + } + + // + signalPusher++; + } + } + + // + // XCHMAMX ... + if (mIsXCHMAMXSignalProviderEnable) + { + // + hasXCHMAMXSignal = XCHMAMXHasSpecifiedLongSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXCHMAMXSignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XCHMAMX); + } + + // + signalPusher++; + } + } + // result = // - hasX121XSPSignal + hasXSPSignal // || // @@ -3306,20 +5345,28 @@ private: signalPusher = 0; // - bool hasX121XSPSignal = false; + bool hasXSPSignal = false; bool hasXTESTSignal = false; bool hasX786Signal = false; bool hasX121Signal = false; bool hasX110Signal = false; bool hasX92Signal = false; bool hasX128Signal = false; + bool hasXTDSignal = false; + bool hasXTAMSignal = false; + bool hasXSISignal = false; + bool hasXTSFISignal = false; + bool hasXOBDLHSignal = false; + bool hasXCHMACCSignal = false; + bool hasXCHMAMNSignal = false; + bool hasXCHMAMXSignal = false; // - // X121XSP ... - if (mIsX121XSPSignalProviderEnable) + // XSP ... + if (mIsXSPSignalProviderEnable) { // - hasX121XSPSignal = X121XSPHasSpecifiedShortSignal( + hasXSPSignal = XSPHasSpecifiedShortSignal( mConditions, providedSL, providedTP, @@ -3327,12 +5374,12 @@ private: ); // - if (hasX121XSPSignal) + if (hasXSPSignal) { // if (!IsValid(provider)) { - provider = ToString(X121XSP); + provider = ToString(XSP); } // @@ -3496,10 +5543,218 @@ private: } } + // + // XTD ... + if (mIsXTDSignalProviderEnable) + { + // + hasXTDSignal = XTDHasSpecifiedShortSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXTDSignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XTD); + } + + // + signalPusher++; + } + } + + // + // XTAM ... + if (mIsXTAMSignalProviderEnable) + { + // + hasXTAMSignal = XTAMHasSpecifiedShortSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXTAMSignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XTAM); + } + + // + signalPusher++; + } + } + + // + // XSI ... + if (mIsXSISignalProviderEnable) + { + // + hasXSISignal = XSIHasSpecifiedShortSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXSISignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XSI); + } + + // + signalPusher++; + } + } + + // + // XTSFI ... + if (mIsXTSFISignalProviderEnable) + { + // + hasXTSFISignal = XTSFIHasSpecifiedShortSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXTSFISignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XTSFI); + } + + // + signalPusher++; + } + } + + // + // XOBDLH ... + if (mIsXOBDLHSignalProviderEnable) + { + // + hasXOBDLHSignal = XOBDLHHasSpecifiedShortSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXOBDLHSignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XOBDLH); + } + + // + signalPusher++; + } + } + + // + // XCHMACC ... + if (mIsXCHMACCSignalProviderEnable) + { + // + hasXCHMACCSignal = XCHMACCHasSpecifiedShortSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXCHMACCSignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XCHMACC); + } + + // + signalPusher++; + } + } + + // + // XCHMAMN ... + if (mIsXCHMAMNSignalProviderEnable) + { + // + hasXCHMAMNSignal = XCHMAMNHasSpecifiedShortSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXCHMAMNSignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XCHMAMN); + } + + // + signalPusher++; + } + } + + // + // XCHMAMX ... + if (mIsXCHMAMXSignalProviderEnable) + { + // + hasXCHMAMXSignal = XCHMAMXHasSpecifiedShortSignal( + mConditions, + providedSL, + providedTP, + providedR2r // + ); + + // + if (hasXCHMAMXSignal) + { + // + if (!IsValid(provider)) + { + provider = ToString(XCHMAMX); + } + + // + signalPusher++; + } + } + // result = // - hasX121XSPSignal + hasXSPSignal // || // @@ -3525,6 +5780,38 @@ private: // hasX128Signal // + || + // + hasXTDSignal + // + || + // + hasXTAMSignal + // + || + // + hasXSISignal + // + || + // + hasXTSFISignal + // + || + // + hasXOBDLHSignal + // + || + // + hasXCHMACCSignal + // + || + // + hasXCHMAMNSignal + // + || + // + hasXCHMAMXSignal + // ; // @@ -3562,6 +5849,8 @@ private: // int curr = barIndex + 1; int prev = curr + 1; + int mLength = 10; + int mFrom = curr + mLength; // mConditions.symbol = GetSymbol(); @@ -3581,6 +5870,1012 @@ private: mNumberOfItems // ); + // + // Current Market Specified ... + + // + // XTM ... + tmHelper.CopyMain( + barIndex, + mNumberOfItems, + mConditions.tms); + // + mConditions.isXTMPeak = IsIncreasing( + mFrom, + curr, + mConditions.tms); + + // + mConditions.isXTMVale = IsDecreasing( + mFrom, + curr, + mConditions.tms); + + // + mConditions.isXTMBullish = mConditions.bars[curr].low > mConditions.tms[curr]; + bool isXTMBullishPrev = mConditions.bars[prev].low > mConditions.tms[prev]; + + // + mConditions.isXTMBearish = mConditions.bars[curr].high < mConditions.tms[curr]; + bool isXTMBearishPrev = mConditions.bars[prev].high < mConditions.tms[prev]; + + // + mConditions.isXTMNeutural = !mConditions.isXTMBullish && !mConditions.isXTMBearish; + bool isXTMNeuturalPrev = !isXTMBullishPrev && !isXTMBearishPrev; + + // + mConditions.isXTMEndBullish = + // + !mConditions.isXTMBullish && + isXTMBullishPrev + // + ; + + // + mConditions.isXTMEndBearish = + // + !mConditions.isXTMBearish && + isXTMBearishPrev + // + ; + + // + mConditions.isXTMStartBullish = + // + mConditions.isXTMBullish && + !isXTMBullishPrev + // + ; + + // + mConditions.isXTMStartBearish = + // + mConditions.isXTMBearish && + !isXTMBearishPrev + // + ; + + // + mConditions.isXTMEndBullishByNeutural = + // + mConditions.isXTMNeutural && + isXTMBullishPrev + // + ; + + // + mConditions.isXTMEndBearishByNeutural = + // + mConditions.isXTMNeutural && + isXTMBearishPrev + // + ; + + // + mConditions.isXTMStartBullishAfterNeutural = + // + mConditions.isXTMBullish && + isXTMNeuturalPrev + // + ; + + // + mConditions.isXTMStartBearishAfterNeutural = + // + mConditions.isXTMBearish && + isXTMNeuturalPrev + // + ; + + // + // XAMA ... + amaHelper.CopyMain( + barIndex, + mNumberOfItems, + mConditions.amas); + + // + mConditions.isXAMAPeak = IsIncreasing( + mFrom, + curr, + mConditions.amas); + + // + mConditions.isXAMAVale = IsDecreasing( + mFrom, + curr, + mConditions.amas); + + // + mConditions.isXAMABullish = mConditions.bars[curr].low > mConditions.amas[curr]; + bool isXAMABullishPrev = mConditions.bars[prev].low > mConditions.amas[prev]; + + // + mConditions.isXAMABearish = mConditions.bars[curr].high < mConditions.amas[curr]; + bool isXAMABearishPrev = mConditions.bars[prev].high < mConditions.amas[prev]; + + // + mConditions.isXAMANeutural = !mConditions.isXAMABullish && !mConditions.isXAMABearish; + bool isXAMANeuturalPrev = !isXAMABullishPrev && !isXAMABearishPrev; + + // + mConditions.isXAMAEndBullish = + // + !mConditions.isXAMABullish && + isXAMABullishPrev + // + ; + + // + mConditions.isXAMAEndBearish = + // + !mConditions.isXAMABearish && + isXAMABearishPrev + // + ; + + // + mConditions.isXAMAStartBullish = + // + mConditions.isXAMABullish && + !isXAMABullishPrev + // + ; + + // + mConditions.isXAMAStartBearish = + // + mConditions.isXAMABearish && + !isXAMABearishPrev + // + ; + + // + mConditions.isXAMAEndBullishByNeutural = + // + mConditions.isXAMANeutural && + isXAMABullishPrev + // + ; + + // + mConditions.isXAMAEndBearishByNeutural = + // + mConditions.isXAMANeutural && + isXAMABearishPrev + // + ; + + // + mConditions.isXAMAStartBullishAfterNeutural = + // + mConditions.isXAMABullish && + isXAMANeuturalPrev + // + ; + + // + mConditions.isXAMAStartBearishAfterNeutural = + // + mConditions.isXAMABearish && + isXAMANeuturalPrev + // + ; + + // + // XFI ... + fiHelper.CopyMain( + barIndex, + mNumberOfItems, + mConditions.fis); + + // + mConditions.isXFIPeak = IsIncreasing( + mFrom, + curr, + mConditions.fis); + + // + mConditions.isXFIVale = IsDecreasing( + mFrom, + curr, + mConditions.fis); + + // + mConditions.isXFIOverZero = mConditions.fis[curr] > 0; + + // + mConditions.isXFICrossedOverZero = + // + mConditions.isXFIOverZero && + mConditions.fis[prev] <= 0 + // + ; + + // + mConditions.isXFIUnderZero = mConditions.fis[curr] < 0; + + // + mConditions.isXFICrossedUnderZero = + // + mConditions.isXFIUnderZero && + mConditions.fis[prev] >= 0 + // + ; + + // + // XOBD ... + obdHelper.CopyMain( + barIndex, + mNumberOfItems, + mConditions.obds); + + // + mConditions.isXOBDSwingLow = mConditions.obds[curr] == X_SWING_LOW; + mConditions.isXOBDSwingHigh = mConditions.obds[curr] == X_SWING_HIGH; + + // + // XRSI ... + rsiHelper.CopyMain( + barIndex, + mNumberOfItems, + mConditions.rsis); + + // + double shortEntryValue = mInputs.rsiInputs.shortEntryValue; + double shortExitValue = mInputs.rsiInputs.shortExitValue; + double longEntryValue = mInputs.rsiInputs.longEntryValue; + double longExitValue = mInputs.rsiInputs.longExitValue; + + // + mConditions.isXRSIPeak = IsIncreasing( + mFrom, + curr, + mConditions.rsis); + + // + mConditions.isXRSIVale = IsDecreasing( + mFrom, + curr, + mConditions.rsis); + + // + mConditions.isXRSICrossedOverLongExit = + // + mConditions.rsis[curr] > longExitValue && + mConditions.rsis[prev] <= longExitValue; + // + ; + + // + mConditions.isXRSICrossedOverLongEntry = + // + mConditions.rsis[curr] > longEntryValue && + mConditions.rsis[prev] <= longEntryValue; + // + ; + + // + mConditions.isXRSICrossedUnderShortExit = + // + mConditions.rsis[curr] < shortExitValue && + mConditions.rsis[prev] >= shortExitValue; + // + ; + + // + mConditions.isXRSICrossedUnderShortEntry = + // + mConditions.rsis[curr] < shortEntryValue && + mConditions.rsis[prev] >= shortEntryValue; + // + ; + + // + // XLH ... + + // + // HH ... + lhHelper.CopyHH( + barIndex, + mNumberOfItems, + mConditions.lhHhs); + + // + // LL ... + lhHelper.CopyLL( + barIndex, + mNumberOfItems, + mConditions.lhLls); + + // + // Signal ... + lhHelper.CopySignal( + barIndex, + mNumberOfItems, + mConditions.lhSignals); + + // + mConditions.isXLHHHIncreased = IsIncreasing( + mFrom, + curr, + mConditions.lhHhs); + + // + mConditions.isXLHHHDecreased = IsDecreasing( + mFrom, + curr, + mConditions.lhHhs); + + // + mConditions.isXLHLLIncreased = IsIncreasing( + mFrom, + curr, + mConditions.lhLls); + + // + mConditions.isXLHLLDecreased = IsDecreasing( + mFrom, + curr, + mConditions.lhLls); + + // + mConditions.isXLHLowAttachedLL = mConditions.bars[curr].low == mConditions.lhLls[curr]; + + // + mConditions.isXLHHighAttachedHH = mConditions.bars[curr].high == mConditions.lhHhs[curr]; + ; + + // + mConditions.isXLHHHSameInLength = IsSame(mConditions.lhHhs); + + // + mConditions.isXLHLLSameInLength = IsSame(mConditions.lhLls); + + // + mConditions.isXLHPriceOverSignal = mConditions.bars[curr].low > mConditions.lhSignals[curr]; + + // + mConditions.isXLHPriceUnderSignal = mConditions.bars[curr].high < mConditions.lhSignals[curr]; + + // + mConditions.isXLHPriceInSignalRange = !mConditions.isXLHPriceOverSignal && !mConditions.isXLHPriceUnderSignal; + + // + mConditions.isXLHPriceCrossedOverSignal = + // + mConditions.isXLHPriceOverSignal && + !(mConditions.bars[prev].low > mConditions.lhSignals[prev]) + // + ; + + // + mConditions.isXLHPriceCrossedUnderSignal = + // + mConditions.isXLHPriceUnderSignal && + !(mConditions.bars[curr].high < mConditions.lhSignals[curr]) + // + ; + + // + // XTD ... + + // + // Bullish ... + tdHelper.CopyBullish( + barIndex, + mNumberOfItems, + mConditions.tdBullishs); + + // + // Bearish ... + tdHelper.CopyBearish( + barIndex, + mNumberOfItems, + mConditions.tdBearishs); + + // + // Signal ... + tdHelper.CopySignal( + barIndex, + mNumberOfItems, + mConditions.tdSignals); + + // + mConditions.isXTDSignalPeak = IsIncreasing( + mFrom, + curr, + mConditions.tdSignals); + + // + mConditions.isXTDSignalVale = IsDecreasing( + mFrom, + curr, + mConditions.tdSignals); + + // + mConditions.isXTDBullishPeak = IsIncreasing( + mFrom, + curr, + mConditions.tdBullishs); + + // + mConditions.isXTDBullishVale = IsDecreasing( + mFrom, + curr, + mConditions.tdBullishs); + + // + mConditions.isXTDBearishPeak = IsIncreasing( + mFrom, + curr, + mConditions.tdBearishs); + + // + mConditions.isXTDBearishVale = IsDecreasing( + mFrom, + curr, + mConditions.tdBearishs); + + // + mConditions.isXTDBullOverBear = mConditions.tdBullishs[curr] > mConditions.tdBearishs[curr]; + bool isXTDBullOverBearPrev = mConditions.tdBullishs[prev] > mConditions.tdBearishs[prev]; + + // + mConditions.isXTDBullUnderBear = mConditions.tdBullishs[curr] < mConditions.tdBearishs[curr]; + bool isXTDBullUnderBearPrev = mConditions.tdBullishs[prev] < mConditions.tdBearishs[prev]; + + // + mConditions.isXTDSignalOverBear = mConditions.tdSignals[curr] > mConditions.tdBearishs[curr]; + bool isXTDSignalOverBearPrev = mConditions.tdSignals[prev] > mConditions.tdBearishs[prev]; + + // + mConditions.isXTDSignalUnderBear = mConditions.tdSignals[curr] < mConditions.tdBearishs[curr]; + bool isXTDSignalUnderBearPrev = mConditions.tdSignals[prev] < mConditions.tdBearishs[prev]; + + // + mConditions.isXTDBullCrossedOverBear = + mConditions.isXTDBullOverBear && + !isXTDBullOverBearPrev; + + // + mConditions.isXTDBullCrossedUnderBear = + mConditions.isXTDBullUnderBear && + !isXTDBullUnderBearPrev; + + // + mConditions.isXTDSignalCrossedOverBear = + mConditions.isXTDSignalOverBear && + !isXTDSignalOverBearPrev; + + // + mConditions.isXTDSignalCrossedUnderBear = + mConditions.isXTDSignalUnderBear && + !isXTDSignalUnderBearPrev; + + // + // XTS ... + + // + // Current ... + tsHelper.CopyCurrent( + barIndex, + mNumberOfItems, + mConditions.tsCurrents); + + // + // Nearest ... + tsHelper.CopyNearest( + barIndex, + mNumberOfItems, + mConditions.tsNearests); + + // + // Mediest ... + tsHelper.CopyMediest( + barIndex, + mNumberOfItems, + mConditions.tsMediests); + + // + // Farest ... + tsHelper.CopyFarest( + barIndex, + mNumberOfItems, + mConditions.tsFarests); + + // + double current = mConditions.tsCurrents[curr]; + double currentPrev = mConditions.tsCurrents[prev]; + + // + double nearest = mConditions.tsNearests[curr]; + double nearestPrev = mConditions.tsNearests[prev]; + + // + double mediest = mConditions.tsMediests[curr]; + double mediestPrev = mConditions.tsMediests[prev]; + + // + double farest = mConditions.tsFarests[curr]; + double farestPrev = mConditions.tsFarests[prev]; + + // + double tsValues[] = {current, nearest, mediest, farest}; + double tsMax = GetMax(tsValues); + double tsMin = GetMin(tsValues); + + // + double tsPrevValues[] = {currentPrev, nearestPrev, mediestPrev, farestPrev}; + double tsPrevMax = GetMax(tsPrevValues); + double tsPrevMin = GetMin(tsPrevValues); + + // + mConditions.isXTSAllSame = + // + current == nearest && + nearest == mediest && + mediest == farest + // + ; + + // + mConditions.isXTSCurrentMin = current == tsMin; + mConditions.isXTSCurrentMax = current == tsMax; + + // + mConditions.isXTSCurrentOverFarest = current > farest; + bool isXTSCurrentOverFarestPrev = currentPrev > farestPrev; + + // + mConditions.isXTSCurrentOverNearest = current > nearest; + bool isXTSCurrentOverNearestPrev = currentPrev > nearestPrev; + + // + mConditions.isXTSCurrentOverMediest = current > mediest; + bool isXTSCurrentOverMediestPrev = currentPrev > mediestPrev; + + // + mConditions.isXTSCurrentUnderFarest = current < farest; + bool isXTSCurrentUnderFarestPrev = currentPrev < farestPrev; + + // + mConditions.isXTSCurrentUnderNearest = current < nearest; + bool isXTSCurrentUnderNearestPrev = currentPrev < nearestPrev; + + // + mConditions.isXTSCurrentUnderMediest = current < mediest; + bool isXTSCurrentUnderMediestPrev = currentPrev < mediestPrev; + + // + mConditions.isXTSCurrentCrossedOverFarest = + mConditions.isXTSCurrentOverFarest && + !isXTSCurrentOverFarestPrev; + + // + mConditions.isXTSCurrentCrossedOverNearest = + mConditions.isXTSCurrentOverNearest && + !isXTSCurrentOverNearestPrev; + + // + mConditions.isXTSCurrentCrossedOverMediest = + mConditions.isXTSCurrentOverMediest && + !isXTSCurrentOverMediestPrev; + + // + mConditions.isXTSCurrentCrossedUnderFarest = + mConditions.isXTSCurrentUnderFarest && + !isXTSCurrentUnderFarestPrev; + + // + mConditions.isXTSCurrentCrossedUnderNearest = + mConditions.isXTSCurrentUnderNearest && + !isXTSCurrentUnderNearestPrev; + + // + mConditions.isXTSCurrentCrossedUnderMediest = + mConditions.isXTSCurrentUnderMediest && + !isXTSCurrentUnderMediestPrev; + + // + // XCHMA ... + + // + // Short ... + + // + // Fast ... + chmaHelper.CopySCFast( + barIndex, + mNumberOfItems, + mConditions.chmaScFasts); + + // + // Slow ... + chmaHelper.CopySCSlow( + barIndex, + mNumberOfItems, + mConditions.chmaScSlows); + + // + // Medium ... + + // + // Fast ... + chmaHelper.CopyMCFast( + barIndex, + mNumberOfItems, + mConditions.chmaMcFasts); + + // + // Slow ... + chmaHelper.CopyMCSlow( + barIndex, + mNumberOfItems, + mConditions.chmaMcSlows); + + // + // Long ... + + // + // Fast ... + chmaHelper.CopyLCFast( + barIndex, + mNumberOfItems, + mConditions.chmaLcFasts); + + // + // Slow ... + chmaHelper.CopyLCSlow( + barIndex, + mNumberOfItems, + mConditions.chmaLcSlows); + + // + // Hot States ... + chmaHelper.CopyHotState( + barIndex, + mNumberOfItems, + mConditions.chmaHotStates); + + // + double scFast = mConditions.chmaScFasts[curr]; + double scSlow = mConditions.chmaScSlows[curr]; + double scFastPrev = mConditions.chmaScFasts[prev]; + double scSlowPrev = mConditions.chmaScSlows[prev]; + + // + double mcFast = mConditions.chmaMcFasts[curr]; + double mcSlow = mConditions.chmaMcSlows[curr]; + double mcFastPrev = mConditions.chmaMcFasts[prev]; + double mcSlowPrev = mConditions.chmaMcSlows[prev]; + + // + double lcFast = mConditions.chmaLcFasts[curr]; + double lcSlow = mConditions.chmaLcSlows[curr]; + double lcFastPrev = mConditions.chmaLcFasts[prev]; + double lcSlowPrev = mConditions.chmaLcSlows[prev]; + + // + double chmaValues[] = { + scFast, + scSlow, + mcFast, + mcSlow, + lcFast, + lcSlow}; + double chmaNonSCValues[] = { + mcFast, + mcSlow, + lcFast, + lcSlow}; + double chmaMin = GetMin(chmaValues); + double chmaMax = GetMax(chmaValues); + double chmaNonSCMin = GetMin(chmaNonSCValues); + double chmaNonSCMax = GetMax(chmaNonSCValues); + + // + double chmaValuesPrev[] = { + scFastPrev, + scSlowPrev, + mcFastPrev, + mcSlowPrev, + lcFastPrev, + lcSlowPrev}; + double chmaNonSCValuesPrev[] = { + mcFastPrev, + mcSlowPrev, + lcFastPrev, + lcSlowPrev}; + double chmaMinPrev = GetMin(chmaValuesPrev); + double chmaMaxPrev = GetMax(chmaValuesPrev); + double chmaNonSCMinPrev = GetMin(chmaNonSCValuesPrev); + double chmaNonSCMaxPrev = GetMax(chmaNonSCValuesPrev); + + // + mConditions.isXCHMASCOverMax = MathMin(scFast, scSlow) > chmaNonSCMax; + bool isXCHMASCOverMaxPrev = MathMin(scFastPrev, scSlowPrev) > chmaNonSCMaxPrev; + + // + mConditions.isXCHMASCOverMin = MathMin(scFast, scSlow) > chmaNonSCMin; + bool isXCHMASCOverMinPrev = MathMin(scFastPrev, scSlowPrev) > chmaNonSCMinPrev; + + // + mConditions.isXCHMASCUnderMax = MathMax(scFast, scSlow) < chmaNonSCMax; + bool isXCHMASCUnderMaxPrev = MathMax(scFastPrev, scSlowPrev) < chmaNonSCMaxPrev; + + // + mConditions.isXCHMASCUnderMin = MathMax(scFast, scSlow) < chmaNonSCMin; + bool isXCHMASCUnderMinPrev = MathMax(scFastPrev, scSlowPrev) < chmaNonSCMinPrev; + + // + mConditions.isXCHMASCCrossedOverMax = + mConditions.isXCHMASCOverMax && + !isXCHMASCOverMaxPrev; + + // + mConditions.isXCHMASCCrossedUnderMax = + mConditions.isXCHMASCUnderMax && + !isXCHMASCUnderMaxPrev; + + // + mConditions.isXCHMASCCrossedOverMin = + mConditions.isXCHMASCOverMin && + !isXCHMASCOverMinPrev; + + // + mConditions.isXCHMASCCrossedUnderMin = + mConditions.isXCHMASCUnderMin && + !isXCHMASCUnderMinPrev; + + // + // Short ... + + // + mConditions.isXCHMASCPeak = IsIncreasing( + mFrom, + curr, + mConditions.chmaScFasts); + + // + mConditions.isXCHMASCVale = IsDecreasing( + mFrom, + curr, + mConditions.chmaScFasts); + + // + mConditions.isXCHMASCTrendsUp = IsTrendingUp( + mConditions.chmaScFasts, + mConditions.chmaScSlows); + + // + mConditions.isXCHMASCTrendsDown = IsTrendingDown( + mConditions.chmaScFasts, + mConditions.chmaScSlows); + + // + mConditions.isXCHMASCFastOverSlow = scFast > scSlow; + bool isXCHMASCFastOverSlowPrev = scFastPrev > scSlowPrev; + + // + mConditions.isXCHMASCFastUnderSlow = scFast < scSlow; + bool isXCHMASCFastUnderSlowPrev = scFastPrev < scSlowPrev; + + // + mConditions.isXCHMASCFastCrossedOverSlow = + mConditions.isXCHMASCFastOverSlow && + !isXCHMASCFastOverSlowPrev; + + // + mConditions.isXCHMASCFastCrossedUnderSlow = + mConditions.isXCHMASCFastUnderSlow && + !isXCHMASCFastUnderSlowPrev; + + // + // Medium ... + + // + mConditions.isXCHMAMCPeak = IsIncreasing( + mFrom, + curr, + mConditions.chmaMcFasts); + + // + mConditions.isXCHMAMCVale = IsDecreasing( + mFrom, + curr, + mConditions.chmaMcFasts); + + // + mConditions.isXCHMAMCTrendsUp = IsTrendingUp( + mConditions.chmaMcFasts, + mConditions.chmaMcSlows); + + // + mConditions.isXCHMAMCTrendsDown = IsTrendingDown( + mConditions.chmaMcFasts, + mConditions.chmaMcSlows); + + // + mConditions.isXCHMAMCFastOverSlow = mcFast > mcSlow; + bool isXCHMAMCFastOverSlowPrev = mcFastPrev > mcSlowPrev; + + // + mConditions.isXCHMAMCFastUnderSlow = mcFast < mcSlow; + bool isXCHMAMCFastUnderSlowPrev = mcFastPrev < mcSlowPrev; + + // + mConditions.isXCHMAMCFastCrossedOverSlow = + mConditions.isXCHMAMCFastOverSlow && + !isXCHMAMCFastOverSlowPrev; + + // + mConditions.isXCHMAMCFastCrossedUnderSlow = + mConditions.isXCHMAMCFastUnderSlow && + !isXCHMAMCFastUnderSlowPrev; + + // + // Long ... + + // + mConditions.isXCHMALCPeak = IsIncreasing( + mFrom, + curr, + mConditions.chmaLcFasts); + + // + mConditions.isXCHMALCVale = IsDecreasing( + mFrom, + curr, + mConditions.chmaLcFasts); + + // + mConditions.isXCHMALCTrendsUp = IsTrendingUp( + mConditions.chmaLcFasts, + mConditions.chmaLcSlows); + + // + mConditions.isXCHMALCTrendsDown = IsTrendingDown( + mConditions.chmaMcFasts, + mConditions.chmaMcSlows); + + // + mConditions.isXCHMALCFastOverSlow = lcFast > lcSlow; + bool isXCHMALCFastOverSlowPrev = lcFastPrev > lcSlowPrev; + + // + mConditions.isXCHMALCFastUnderSlow = lcFast < lcSlow; + bool isXCHMALCFastUnderSlowPrev = lcFastPrev < lcSlowPrev; + + // + mConditions.isXCHMALCFastCrossedOverSlow = + mConditions.isXCHMALCFastOverSlow && + !isXCHMALCFastOverSlowPrev; + + // + mConditions.isXCHMALCFastCrossedUnderSlow = + mConditions.isXCHMALCFastUnderSlow && + !isXCHMALCFastUnderSlowPrev; + + // + // XCHLH ... + + // + // Short ... + + // + // HH ... + chlhHelper.CopySCHH( + barIndex, + mNumberOfItems, + mConditions.chlhScHHs); + + // + // LL ... + chlhHelper.CopySCLL( + barIndex, + mNumberOfItems, + mConditions.chlhScLLs); + + // + // Medium ... + + // + // HH ... + chlhHelper.CopyMCHH( + barIndex, + mNumberOfItems, + mConditions.chlhMcHHs); + + // + // LL ... + chlhHelper.CopyMCLL( + barIndex, + mNumberOfItems, + mConditions.chlhMcLLs); + + // + // Long ... + + // + // HH ... + chlhHelper.CopyLCHH( + barIndex, + mNumberOfItems, + mConditions.chlhLcHHs); + + // + // LL ... + chlhHelper.CopyLCLL( + barIndex, + mNumberOfItems, + mConditions.chlhLcLLs); + + // + // Hot State ... + chlhHelper.CopyHotState( + barIndex, + mNumberOfItems, + mConditions.chlhHotStates); + + // + mConditions.isXCHLHSameHHs = + // + mConditions.chlhScHHs[curr] == mConditions.chlhMcHHs[curr] && + mConditions.chlhMcHHs[curr] == mConditions.chlhLcHHs[curr] + // + ; + + // + mConditions.isXCHLHSameLLs = + // + mConditions.chlhScLLs[curr] == mConditions.chlhMcLLs[curr] && + mConditions.chlhMcLLs[curr] == mConditions.chlhLcLLs[curr] + // + ; + + // + mConditions.isXCHLHSCMCHHSame = + // + mConditions.chlhScHHs[curr] == mConditions.chlhMcHHs[curr] + // + ; + + // + mConditions.isXCHLHSCMCLLSame = + // + mConditions.chlhScLLs[curr] == mConditions.chlhMcLLs[curr] + // + ; + + // + mConditions.isXCHLHSCLCHHSame = + // + mConditions.chlhScHHs[curr] == mConditions.chlhLcLLs[curr] + // + ; + + // + mConditions.isXCHLHSCLCLLSame = + // + mConditions.chlhScLLs[curr] == mConditions.chlhLcLLs[curr] + // + ; + + // + mConditions.isXCHLHMCLCHHSame = + // + mConditions.chlhMcHHs[curr] == mConditions.chlhLcHHs[curr] + // + ; + + // + mConditions.isXCHLHMCLCLLSame = + // + mConditions.chlhMcLLs[curr] == mConditions.chlhLcLLs[curr] + // + ; + // // X121 Cycles Conditions ... @@ -3620,14 +6915,601 @@ private: ); } + // + // Check Market Conditions is Ready for Long Signals or not ... + bool IsReadyForLong( + X121MarketConditions &mConditions, // Market Conditions ... + bool checkXCHMAMin = true, // Force Check XCHMA Min State + bool checkXCHMAMax = true, // Force Check XCHMA Max State + bool checkXCHMACycles = true, // Force Check XCHMA Cycles State + bool checkXCHMAPeaks = true, // Force Check XCHMA Peaks State + bool checkXCHMATrendPowers = true, // Force Check XCHMA Trend Powers + bool checkXOBD = true, // Force Check XOBD State + bool checkXTS = true // Force Check XTS State + ) + { + // + bool result = true; + + // + if (checkXCHMAMin) + { + // + result = + // + // XCHMA MIN ... + !( + // + (mConditions.isXCHMASCOverMin || + mConditions.isXCHMASCCrossedOverMin) && + (mConditions.isXCHMASCUnderMin || + mConditions.isXCHMASCCrossedUnderMin) + // + ); + } + + // + if (checkXCHMAMax && result) + { + // + result = + // + // XCHMA MAX ... + !( + // + (mConditions.isXCHMASCOverMax || + mConditions.isXCHMASCCrossedOverMax) && + (mConditions.isXCHMASCUnderMax || + mConditions.isXCHMASCCrossedUnderMax) + // + ) + // + ; + } + + // + if (checkXCHMACycles && result) + { + // + result = + // + // Check XCHMA Trend Bullish ... + ( + // + // All Cycles Bullish ... + ( + // + // SC ... + (mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) + // + && + // + // MC ... + (mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) + // + && + // + // LC ... + (mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) + // + ) + // + || + // + // Two Cycle Fully Bullish ... + ( + // + // SC and MC ... + ( + // + // SC ... + (mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) + // + && + // + // MC ... + (mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) + // + ) + // + || + // + // SC and LC ... + ( + // + // SC ... + (mConditions.isXCHMASCFastOverSlow || + mConditions.isXCHMASCFastCrossedOverSlow) + // + && + // + // LC ... + (mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) + // + ) + // + || + // + // MC and LC ... + ( + // + // MC ... + (mConditions.isXCHMAMCFastOverSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) + // + && + // + // LC ... + (mConditions.isXCHMALCFastOverSlow || + mConditions.isXCHMALCFastCrossedOverSlow) + // + ) + // + ) + // + ) + // + ; + } + + // + if (checkXCHMAPeaks && result) + { + // + result = + // + // XCHMA Check Peaks ... + !( + // + // All Cycles Peak ... + (mConditions.isXCHMASCPeak && + mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCPeak) + // + || + // + ( + // + // SC MC ... + (mConditions.isXCHMASCPeak && + mConditions.isXCHMAMCPeak) + // + || + // + // SC LC ... + (mConditions.isXCHMASCPeak && + mConditions.isXCHMALCPeak) + // + || + // + // MC LC ... + (mConditions.isXCHMAMCPeak && + mConditions.isXCHMALCPeak) + // + ) + // + ) + // + ; + } + + // + if (checkXCHMATrendPowers && result) + { + // + result = + // + // XCHMA Check Trends Power ... + !( + // + // All Trends Down ... + (mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMALCTrendsDown) + // + || + // + // Twisted pairs ... + ( + // + (mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMAMCTrendsDown) + // + || + // + (mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMALCTrendsDown) + // + ) + // + ) + // + ; + } + + // + if (checkXOBD && result) + { + // + result = + // + // XOBD Check Swings ... + !mConditions.isXOBDSwingLow + // + ; + } + + // + if (checkXTS && result) + { + result = + // + // XTS Check ... + !( + // + mConditions.isXTSCurrentMin && + // + ( + // + // All Under ... + ( + (mConditions.isXTSCurrentUnderNearest || + mConditions.isXTSCurrentCrossedUnderNearest) && + (mConditions.isXTSCurrentUnderMediest || + mConditions.isXTSCurrentCrossedUnderMediest) && + (mConditions.isXTSCurrentUnderFarest || + mConditions.isXTSCurrentCrossedUnderFarest)) + // + || + // + // Pairs ... + ( + // + ((mConditions.isXTSCurrentUnderNearest || + mConditions.isXTSCurrentCrossedUnderNearest) && + (mConditions.isXTSCurrentUnderMediest || + mConditions.isXTSCurrentCrossedUnderMediest)) + // + || + // + ((mConditions.isXTSCurrentUnderNearest || + mConditions.isXTSCurrentCrossedUnderNearest) && + (mConditions.isXTSCurrentUnderFarest || + mConditions.isXTSCurrentCrossedUnderFarest)) + // + || + // + ((mConditions.isXTSCurrentUnderMediest || + mConditions.isXTSCurrentCrossedUnderMediest) && + (mConditions.isXTSCurrentUnderFarest || + mConditions.isXTSCurrentCrossedUnderFarest)) + // + ) + // + ) + // + ) + // + ; + } + + // + return result; + } + + // + // Check Market Conditions is Ready for Short Signals or not ... + bool IsReadyForShort( + X121MarketConditions &mConditions, // Market Conditions ... + bool checkXCHMAMin = true, // Force Check XCHMA Min State + bool checkXCHMAMax = true, // Force Check XCHMA Max State + bool checkXCHMACycles = true, // Force Check XCHMA Cycles State + bool checkXCHMAVales = true, // Force Check XCHMA Vales State + bool checkXCHMATrendPowers = true, // Force Check XCHMA Trend Powers + bool checkXOBD = true, // Force Check XOBD State + bool checkXTS = true // Force Check XTS State + ) + { + // + bool result = true; + + // + if (checkXCHMAMin) + { + // + result = + // + // XCHMA MIN ... + !( + // + (mConditions.isXCHMASCOverMin || + mConditions.isXCHMASCCrossedOverMin) && + (mConditions.isXCHMASCUnderMin || + mConditions.isXCHMASCCrossedUnderMin) + // + ); + } + + // + if (checkXCHMAMax && result) + { + // + result = + // + // XCHMA MAX ... + !( + // + (mConditions.isXCHMASCOverMax || + mConditions.isXCHMASCCrossedOverMax) && + (mConditions.isXCHMASCUnderMax || + mConditions.isXCHMASCCrossedUnderMax) + // + ) + // + ; + } + + // + if (checkXCHMACycles && result) + { + // + result = + // + // Check XCHMA Trend Bullish ... + ( + // + // All Cycles Bullish ... + ( + // + // SC ... + (mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) + // + && + // + // MC ... + (mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedUnderSlow) + // + && + // + // LC ... + (mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) + // + ) + // + || + // + // Two Cycle Fully Bullish ... + ( + // + // SC and MC ... + ( + // + // SC ... + (mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedOverSlow) + // + && + // + // MC ... + (mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) + // + ) + // + || + // + // SC and LC ... + ( + // + // SC ... + (mConditions.isXCHMASCFastUnderSlow || + mConditions.isXCHMASCFastCrossedUnderSlow) + // + && + // + // LC ... + (mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedUnderSlow) + // + ) + // + || + // + // MC and LC ... + ( + // + // MC ... + (mConditions.isXCHMAMCFastUnderSlow || + mConditions.isXCHMAMCFastCrossedOverSlow) + // + && + // + // LC ... + (mConditions.isXCHMALCFastUnderSlow || + mConditions.isXCHMALCFastCrossedOverSlow) + // + ) + // + ) + // + ) + // + ; + } + + // + if (checkXCHMAVales && result) + { + // + result = + // + // XCHMA Check Vales ... + !( + // + // All Cycles Vale ... + (mConditions.isXCHMASCVale && + mConditions.isXCHMAMCVale && + mConditions.isXCHMALCVale) + // + || + // + ( + // + // SC MC ... + (mConditions.isXCHMASCVale && + mConditions.isXCHMAMCVale) + // + || + // + // SC LC ... + (mConditions.isXCHMASCVale && + mConditions.isXCHMALCVale) + // + || + // + // MC LC ... + (mConditions.isXCHMAMCVale && + mConditions.isXCHMALCVale) + // + ) + // + ) + // + ; + } + + // + if (checkXCHMATrendPowers && result) + { + // + result = + // + // XCHMA Check Trends Power ... + !( + // + // All Trends Down ... + (mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMALCTrendsDown) + // + || + // + // Twisted pairs ... + ( + // + (mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMAMCTrendsDown) + // + || + // + (mConditions.isXCHMASCTrendsDown && + mConditions.isXCHMALCTrendsDown) + // + || + // + (mConditions.isXCHMAMCTrendsDown && + mConditions.isXCHMALCTrendsDown) + // + ) + // + ) + // + ; + } + + // + if (checkXOBD && result) + { + // + result = + // + // XOBD Check Swings ... + !mConditions.isXOBDSwingHigh + // + ; + } + + // + if (checkXTS && result) + { + // + result = + // + // XTS Check ... + !( + // + mConditions.isXTSCurrentMax && + // + ( + // + // All Over ... + ( + (mConditions.isXTSCurrentOverNearest || + mConditions.isXTSCurrentCrossedOverNearest) && + (mConditions.isXTSCurrentOverMediest || + mConditions.isXTSCurrentCrossedOverMediest) && + (mConditions.isXTSCurrentOverFarest || + mConditions.isXTSCurrentCrossedOverFarest)) + // + || + // + // Pairs ... + ( + // + ((mConditions.isXTSCurrentOverNearest || + mConditions.isXTSCurrentCrossedOverNearest) && + (mConditions.isXTSCurrentOverMediest || + mConditions.isXTSCurrentCrossedOverMediest)) + // + || + // + ((mConditions.isXTSCurrentOverNearest || + mConditions.isXTSCurrentCrossedOverNearest) && + (mConditions.isXTSCurrentOverFarest || + mConditions.isXTSCurrentCrossedOverFarest)) + // + || + // + ((mConditions.isXTSCurrentOverMediest || + mConditions.isXTSCurrentCrossedOverMediest) && + (mConditions.isXTSCurrentOverFarest || + mConditions.isXTSCurrentCrossedOverFarest)) + // + ) + // + ) + // + ) + // + ; + } + + // + return result; + } + // // Signalling based On Signallers ... // - // X121XSP ... + // Longs ... // - bool X121XSPHasSpecifiedLongSignal( + bool XSPHasSpecifiedLongSignal( X121MarketConditions &mConditions, // double &sl, // Provided SL ... double &tp, // Provided TP ... @@ -4595,7 +8477,194 @@ private: } // - bool X121XSPHasSpecifiedShortSignal( + // XTD ... + bool XTDHasSpecifiedLongSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // XTAM ... + bool XTAMHasSpecifiedLongSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // XSI ... + bool XSIHasSpecifiedLongSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // XTSFI ... + bool XTSFIHasSpecifiedLongSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // XOBDLH ... + bool XOBDLHHasSpecifiedLongSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // XCHMACC ... + bool XCHMACCHasSpecifiedLongSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // XCHMAMN ... + bool XCHMAMNHasSpecifiedLongSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // XCHMAMX ... + bool XCHMAMXHasSpecifiedLongSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // Short ... + + // + bool XSPHasSpecifiedShortSignal( X121MarketConditions &mConditions, // double &sl, // Provided SL ... double &tp, // Provided TP ... @@ -5556,6 +9625,1157 @@ private: return result; } + // + // XTD ... + bool XTDHasSpecifiedShortSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // XTAM ... + bool XTAMHasSpecifiedShortSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // XSI ... + bool XSIHasSpecifiedShortSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // XTSFI ... + bool XTSFIHasSpecifiedShortSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // XOBDLH ... + bool XOBDLHHasSpecifiedShortSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // XCHMACC ... + bool XCHMACCHasSpecifiedShortSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // XCHMAMN ... + bool XCHMAMNHasSpecifiedShortSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // XCHMAMX ... + bool XCHMAMXHasSpecifiedShortSignal( + X121MarketConditions &mConditions, // + double &sl, // Provided SL ... + double &tp, // Provided TP ... + double &r2r // Risk Reward Ratio ... + ) + { + // + bool result = false; + + // + result = + // + false + // + ; + + // + return result; + } + + // + // Base Signals ... + // Common Conditions ... + + // + bool HasBaseLongConditions( + X121MarketConditions &mConditions, + int &pusher // + ) + { + // + bool result = false; + + // + int count = 0; + + // + bool hasXTDConditions = XTDHasLongConditions(mConditions); + if (hasXTDConditions) + { + count++; + } + bool hasXTAMConditions = XTAMHasLongConditions(mConditions); + if (hasXTAMConditions) + { + count++; + } + bool hasXSIConditions = XSIHasLongConditions(mConditions); + if (hasXSIConditions) + { + count++; + } + bool hasXTSFIConditions = XTSFIHasLongConditions(mConditions); + if (hasXTSFIConditions) + { + count++; + } + bool hasXOBDLHConditions = XOBDLHHasLongConditions(mConditions); + if (hasXOBDLHConditions) + { + count++; + } + bool hasXCHMACCConditions = XCHMACCHasLongConditions(mConditions); + if (hasXCHMACCConditions) + { + count++; + } + bool hasXCHMAMNConditions = XCHMAMNHasLongConditions(mConditions); + if (hasXCHMAMNConditions) + { + count++; + } + bool hasXCHMAMXConditions = XCHMAMXHasLongConditions(mConditions); + if (hasXCHMAMXConditions) + { + count++; + } + + // + result = count >= 1; + pusher = count; + + // + return result; + } + + // + bool HasBaseShortConditions( + X121MarketConditions &mConditions, + int &pusher // + ) + { + // + bool result = false; + + // + int count = 0; + + // + bool hasXTDConditions = XTDHasShortConditions(mConditions); + if (hasXTDConditions) + { + count++; + } + bool hasXTAMConditions = XTAMHasShortConditions(mConditions); + if (hasXTAMConditions) + { + count++; + } + bool hasXSIConditions = XSIHasShortConditions(mConditions); + if (hasXSIConditions) + { + count++; + } + bool hasXTSFIConditions = XTSFIHasShortConditions(mConditions); + if (hasXTSFIConditions) + { + count++; + } + bool hasXOBDLHConditions = XOBDLHHasShortConditions(mConditions); + if (hasXOBDLHConditions) + { + count++; + } + bool hasXCHMACCConditions = XCHMACCHasShortConditions(mConditions); + if (hasXCHMACCConditions) + { + count++; + } + bool hasXCHMAMNConditions = XCHMAMNHasShortConditions(mConditions); + if (hasXCHMAMNConditions) + { + count++; + } + bool hasXCHMAMXConditions = XCHMAMXHasShortConditions(mConditions); + if (hasXCHMAMXConditions) + { + count++; + } + + // + result = count >= 1; + pusher = count; + + // + return result; + } + + // + // XTD ... + + // + bool XTDHasLongConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + mConditions.isXTDSignalCrossedOverBear + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForLong(mConditions) + // + ) + // + ; + + // + return result; + } + + // + bool XTDHasShortConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + mConditions.isXTDSignalCrossedUnderBear + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForShort(mConditions) + // + ) + // + ; + + // + return result; + } + + // + // XTAM ... + + // + bool XTAMHasLongConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + (mConditions.amas[1] > mConditions.tms[1] && + mConditions.amas[2] > mConditions.tms[2]) + // + && + // + !(mConditions.amas[2] > mConditions.tms[2] && + mConditions.amas[3] > mConditions.tms[3]) + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForLong(mConditions) + // + ) + // + ; + + // + return result; + } + + // + bool XTAMHasShortConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + (mConditions.amas[1] < mConditions.amas[1] && + mConditions.amas[2] < mConditions.amas[2]) + // + && + // + !(mConditions.amas[2] < mConditions.amas[2] && + mConditions.amas[3] < mConditions.amas[3]) + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForShort(mConditions) + // + ) + // + ; + + // + return result; + } + + // + // XSI ... + + // + bool XSIHasLongConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + mConditions.isXRSICrossedOverLongEntry && + mConditions.rsis[3] < mInputs.rsiInputs.longEntryValue + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForLong( + mConditions, + true, // XCHMA Min + true, // XCHMA Max + true, // XCHMA Cycles + true, // XCHMA Peaks + false, // XCHMA Trend Powers + true, // XOBD + true // XTS + ) + // + ) + // + ; + + // + return result; + } + + // + bool XSIHasShortConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + mConditions.isXRSICrossedUnderShortEntry && + mConditions.rsis[3] > mInputs.rsiInputs.shortEntryValue + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForShort( + mConditions, + true, // XCHMA Min + true, // XCHMA Max + true, // XCHMA Cycles + true, // XCHMA Peaks + false, // XCHMA Trend Powers + true, // XOBD + true // XTS + ) + // + ) + // + ; + + // + return result; + } + + // + // XTSFI ... + + // + bool XTSFIHasLongConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + double tsValues[] = { + mConditions.tsCurrents[1], + mConditions.tsNearests[1], + mConditions.tsMediests[1], + mConditions.tsFarests[1], + }; + + // + double tsMin = GetMin(tsValues); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + tsMin == mConditions.tsFarests[1] && + (mConditions.isXTSCurrentOverFarest || + mConditions.isXTSCurrentCrossedOverFarest) && + (mConditions.tsCurrents[1] < mConditions.tsNearests[1] || + mConditions.tsCurrents[1] < mConditions.tsMediests[1]) && + !(mConditions.isXTSCurrentUnderNearest || + mConditions.isXTSCurrentCrossedUnderNearest) + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForLong(mConditions) + // + ) + // + ; + + // + return result; + } + + // + bool XTSFIHasShortConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + double tsValues[] = { + mConditions.tsCurrents[1], + mConditions.tsNearests[1], + mConditions.tsMediests[1], + mConditions.tsFarests[1], + }; + + // + double tsMax = GetMax(tsValues); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + tsMax == mConditions.tsFarests[1] && + (mConditions.isXTSCurrentUnderFarest || + mConditions.isXTSCurrentCrossedUnderFarest) && + (mConditions.tsCurrents[1] > mConditions.tsNearests[1] || + mConditions.tsCurrents[1] > mConditions.tsMediests[1]) && + !(mConditions.isXTSCurrentOverNearest || + mConditions.isXTSCurrentCrossedOverNearest) + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForShort(mConditions) + // + ) + // + ; + + // + return result; + } + + // + // XOBDLH ... + + // + bool XOBDLHHasLongConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + X121MarketConditions mConditions2; + GetMarketConditions( + mConditions, + 2 // + ); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + mConditions2.isXOBDSwingLow && + mConditions2.isXLHLowAttachedLL && + mConditions.lhLls[1] >= mConditions.lhLls[2] + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForLong( + mConditions, + true, // XCHMA Min + true, // XCHMA Max + false, // XCHMA Cycles + false, // XCHMA Peaks + false, // XCHMA Trend Powers + false, // XOBD + false // XTS + ) + // + ) + // + ; + + // + return result; + } + + // + bool XOBDLHHasShortConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + X121MarketConditions mConditions2; + GetMarketConditions( + mConditions, + 2 // + ); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + mConditions2.isXOBDSwingHigh && + mConditions2.isXLHHighAttachedHH && + mConditions.lhHhs[1] <= mConditions.lhHhs[2] + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForShort( + mConditions, + true, // XCHMA Min + true, // XCHMA Max + false, // XCHMA Cycles + false, // XCHMA Peaks + false, // XCHMA Trend Powers + false, // XOBD + false // XTS + ) + // + ) + // + ; + + // + return result; + } + + // + // XCHMACC ... + + // + bool XCHMACCHasLongConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + mConditions.chmaScFasts[1] > mConditions.chmaScSlows[1] && + mConditions.chmaMcFasts[1] > mConditions.chmaMcSlows[1] && + mConditions.chmaLcFasts[1] > mConditions.chmaLcSlows[1] && + // + mConditions.chmaScFasts[2] > mConditions.chmaScSlows[2] && + mConditions.chmaMcFasts[2] > mConditions.chmaMcSlows[2] && + mConditions.chmaLcFasts[2] > mConditions.chmaLcSlows[2] && + // + !( + // + mConditions.chmaScFasts[3] > mConditions.chmaScSlows[3] && + mConditions.chmaMcFasts[3] > mConditions.chmaMcSlows[3] && + mConditions.chmaLcFasts[3] > mConditions.chmaLcSlows[3] + // + ) + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForLong(mConditions) + // + ) + // + ; + + // + return result; + } + + // + bool XCHMACCHasShortConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + mConditions.chmaScFasts[1] < mConditions.chmaScSlows[1] && + mConditions.chmaMcFasts[1] < mConditions.chmaMcSlows[1] && + mConditions.chmaLcFasts[1] < mConditions.chmaLcSlows[1] && + // + mConditions.chmaScFasts[2] < mConditions.chmaScSlows[2] && + mConditions.chmaMcFasts[2] < mConditions.chmaMcSlows[2] && + mConditions.chmaLcFasts[2] < mConditions.chmaLcSlows[2] && + // + !( + // + mConditions.chmaScFasts[3] < mConditions.chmaScSlows[3] && + mConditions.chmaMcFasts[3] < mConditions.chmaMcSlows[3] && + mConditions.chmaLcFasts[3] < mConditions.chmaLcSlows[3] + // + ) + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForLong(mConditions) + // + ) + // + ; + + // + return result; + } + + // + // XCHMAMN ... + + // + bool XCHMAMNHasLongConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + double nonSC2[] = { + mConditions.chmaMcFasts[2], + mConditions.chmaMcSlows[2], + mConditions.chmaLcFasts[2], + mConditions.chmaLcSlows[2], + }; + + // + double nonSCMax2 = GetMax(nonSC2); + double nonSCMin2 = GetMax(nonSC2); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + mConditions.isXCHMASCCrossedOverMin && + mConditions.chmaScFasts[2] < nonSCMin2 && + mConditions.chmaScSlows[2] < nonSCMin2 + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForLong( + mConditions, + true, // XCHMA Min + true, // XCHMA Max + false, // XCHMA Cycles + false, // XCHMA Peaks + false, // XCHMA Trend Powers + true, // XOBD + true // XTS + ) + // + ) + // + ; + + // + return result; + } + + // + bool XCHMAMNHasShortConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + double nonSC2[] = { + mConditions.chmaMcFasts[2], + mConditions.chmaMcSlows[2], + mConditions.chmaLcFasts[2], + mConditions.chmaLcSlows[2], + }; + + // + double nonSCMax2 = GetMax(nonSC2); + double nonSCMin2 = GetMax(nonSC2); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + mConditions.isXCHMASCCrossedUnderMin && + mConditions.chmaScFasts[2] > nonSCMin2 && + mConditions.chmaScSlows[2] > nonSCMin2 + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForLong( + mConditions, + true, // XCHMA Min + true, // XCHMA Max + false, // XCHMA Cycles + false, // XCHMA Peaks + false, // XCHMA Trend Powers + true, // XOBD + true // XTS + ) + // + ) + // + ; + // + return result; + } + + // + // XCHMAMX ... + + // + bool XCHMAMXHasLongConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + double nonSC2[] = { + mConditions.chmaMcFasts[2], + mConditions.chmaMcSlows[2], + mConditions.chmaLcFasts[2], + mConditions.chmaLcSlows[2], + }; + + // + double nonSCMax2 = GetMax(nonSC2); + double nonSCMin2 = GetMax(nonSC2); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + mConditions.isXCHMASCCrossedOverMax && + mConditions.chmaScFasts[2] < nonSCMax2 && + mConditions.chmaScSlows[2] < nonSCMax2 && + MathAbs(nonSCMax2 - mConditions.chmaScFasts[2]) > MathAbs(mConditions.chmaScFasts[2] - mConditions.chmaScSlows[2]) && + MathAbs(nonSCMax2 - mConditions.chmaScSlows[2]) > MathAbs(mConditions.chmaScFasts[2] - mConditions.chmaScSlows[2]) + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForLong( + mConditions, + true, // XCHMA Min + true, // XCHMA Max + false, // XCHMA Cycles + false, // XCHMA Peaks + false, // XCHMA Trend Powers + true, // XOBD + true // XTS + ) + // + ) + // + ; + + // + return result; + } + + // + bool XCHMAMXHasShortConditions( + X121MarketConditions &mConditions // + ) + { + // + bool result = false; + + // + double nonSC2[] = { + mConditions.chmaMcFasts[2], + mConditions.chmaMcSlows[2], + mConditions.chmaLcFasts[2], + mConditions.chmaLcSlows[2], + }; + + // + double nonSCMax2 = GetMax(nonSC2); + double nonSCMin2 = GetMax(nonSC2); + + // + // Start Analysing Market based On Conditions ... + result = + // + // Base Condition: + // each Strategy must has a Base Conditions, which they are usually common combinations + // of Market Properties that must be happens to lookup for signals ... + ( + // + mConditions.isXCHMASCCrossedUnderMax && + mConditions.chmaScFasts[2] > nonSCMax2 && + mConditions.chmaScSlows[2] > nonSCMax2 + // + ) + // + && + // + // Next Step is combine sorts of Conditions which make our choice + // so Exact in Market ... + ( + // + IsReadyForShort( + mConditions, + true, // XCHMA Min + true, // XCHMA Max + false, // XCHMA Cycles + false, // XCHMA Peaks + false, // XCHMA Trend Powers + true, // XOBD + true // XTS + ) + // + ) + // + ; + + // + return result; + } + // }; @@ -5791,14 +11011,21 @@ void GetAllX121SignalProviders(ENUM_X121_SIGNAL_PROVIDERS &result[]) Clean(result); // - Add(X121NONE, result); - Add(X121XSP, result); + Add(XSP, result); Add(XTEST, result); Add(X786, result); Add(X121, result); Add(X110, result); Add(X92, result); Add(X128, result); + Add(XTD, result); + Add(XTAM, result); + Add(XSI, result); + Add(XTSFI, result); + Add(XOBDLH, result); + Add(XCHMACC, result); + Add(XCHMAMN, result); + Add(XCHMAMX, result); } // @@ -5811,7 +11038,7 @@ string ToString(ENUM_X121_SIGNAL_PROVIDERS value) ENUM_X121_SIGNAL_PROVIDERS ToX121SignalProvider(string content) { // - ENUM_X121_SIGNAL_PROVIDERS result = X121NONE; + ENUM_X121_SIGNAL_PROVIDERS result = PROVIDER_NONE; // if (!IsValid(content)) @@ -5820,13 +11047,13 @@ ENUM_X121_SIGNAL_PROVIDERS ToX121SignalProvider(string content) } // - if (content == ToString(X121NONE)) + if (content == ToString(PROVIDER_NONE)) { - result = X121NONE; + result = PROVIDER_NONE; } - else if (content == ToString(X121XSP)) + else if (content == ToString(XSP)) { - result = X121XSP; + result = XSP; } else if (content == ToString(XTEST)) { @@ -5852,6 +11079,38 @@ ENUM_X121_SIGNAL_PROVIDERS ToX121SignalProvider(string content) { result = X128; } + else if (content == ToString(XTD)) + { + result = XTD; + } + else if (content == ToString(XTAM)) + { + result = XTAM; + } + else if (content == ToString(XSI)) + { + result = XSI; + } + else if (content == ToString(XTSFI)) + { + result = XTSFI; + } + else if (content == ToString(XOBDLH)) + { + result = XOBDLH; + } + else if (content == ToString(XCHMACC)) + { + result = XCHMACC; + } + else if (content == ToString(XCHMAMN)) + { + result = XCHMAMN; + } + else if (content == ToString(XCHMAMX)) + { + result = XCHMAMX; + } // return result; diff --git a/Classes/x-saherelm.x121.xea.class.mq5 b/Classes/x-saherelm.x121.xea.class.mq5 index c24a9343..0269d3bd 100644 --- a/Classes/x-saherelm.x121.xea.class.mq5 +++ b/Classes/x-saherelm.x121.xea.class.mq5 @@ -721,9 +721,11 @@ public: // // TODO: // Make them Configurable ... + int maxTrailTPs = 5; int levelsOnClose = 6; + int riskFreeLevel = 2; int requiredAgeForTrail = 0; - int requiredDistanceForTrail = 30; + int requiredDistanceForTrail = 20; // int positionsCount = ArraySize(positions); @@ -792,7 +794,7 @@ public: // double slDiff = PointToPrice(priceDistance, iPosition.symbol); - double appliedSL = slDiff / 2; + double appliedSL = slDiff; // double sl = @@ -848,33 +850,8 @@ public: // double priceDistanceInPoint = PriceToPoint((iPosition.profit - trail.profit) / iPosition.volume, iPosition.symbol); double priceDistance = PointToPrice(priceDistanceInPoint, iPosition.symbol); - if (priceDistance < (requiredDistanceForTrail / 2)) + if (priceDistance < requiredDistanceForTrail) { - // // - // // int positionAge = iPosition.GetAge(iPosition.period); - // if (trail.level >= levelsOnClose) - // { - // // - // string comment = "EQM Close In Profit ..."; - // bool isClosed = mTrader.ClosePositionPack( - // iPosition.ticket, - // iPosition.symbol, - // iPosition.period, - // comment, - // true, - // GetMinProfitPerTrade(), - // GetMinProfitPerVolumeFactor() // - // ); - // if (isClosed) - // { - // // - // RemoveTrail(iPosition.ticket); - - // // - // string message = "EQM Close (" + ToString(iPosition.ticket) + ") In Profit ..."; - // mAlert.Alert(message); - // } - // } continue; } @@ -883,21 +860,20 @@ public: // double slDiff = PointToPrice(priceDistance, iPosition.symbol); - double appliedSL = slDiff / 2; + double appliedSL = (slDiff / 2); // - double selectedValue = iPosition.sl; - - // // - // double selectedValue = - // // - // trail.level == 1 || (isLong - // ? iPosition.sl < iPosition.entry - // : iPosition.sl > iPosition.entry) - // ? iPosition.entry - // : iPosition.sl - // // - // ; + double selectedValue = + // + (riskFreeLevel > 0 && + trail.level == riskFreeLevel) || + (isLong + ? iPosition.sl < iPosition.entry + : iPosition.sl > iPosition.entry) + ? iPosition.entry + : iPosition.sl + // + ; // double sl = @@ -1009,6 +985,12 @@ public: // // Update Exists ... + // + if (trail.level >= maxTrailTPs) + { + continue; + } + // // Check Profit ... bool isProfitPassed = MathAbs(iPosition.profit) > MathAbs(trail.profit); diff --git a/Classes/x-saherelm.x5.provider.class.mq5 b/Classes/x-saherelm.x5.provider.class.mq5 deleted file mode 100644 index a23bcc2c..00000000 --- a/Classes/x-saherelm.x5.provider.class.mq5 +++ /dev/null @@ -1,95417 +0,0 @@ -/////////////////////////////////////////////////////// -// -// SaherElm IT Center MQL5 Class Library -// ---------------------------------------------- -// Name: XSCX5Provider -// Description: provides all Base Provider -// requirements For X5 ... -// -// -// Maintainer: -// ------------ -// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) -// -////////////////////////////////////////////////////// -// -// Global Properties ... -#property library -#property copyright "Copyright 2023, SaherElm IT Center" -#property link "https://www.saherelm.ir" -#property version "1.00" -#property strict - -// -// Imports ... - -// -#include "../Helpers/x-saherelm.xct.helper.mq5" -#include "../Helpers/x-saherelm.xcc.helper.mq5" -#include "../Helpers/x-saherelm.xtm.helper.mq5" -#include "../Helpers/x-saherelm.xama.helper.mq5" -#include "../Helpers/x-saherelm.xlh.helper.mq5" -#include "../Helpers/x-saherelm.xtd.helper.mq5" -#include "../Helpers/x-saherelm.xfi.helper.mq5" -#include "../Helpers/x-saherelm.xts.helper.mq5" -#include "../Helpers/x-saherelm.xrsi.helper.mq5" -#include "../Helpers/x-saherelm.xobd.helper.mq5" -#include "../Helpers/x-saherelm.xchlh.helper.mq5" -#include "../Helpers/x-saherelm.xchma.helper.mq5" - -// -#include "../Classes/x-saherelm.xprovider.class.mq5" - -// -// Definitions ... - -// -// Signallers ... -enum ENUM_X5_SIGNAL_PROVIDERS -{ - // - X5NONE, - // - // X5XSP Expert Support Mechanism ... - X5XSP, - // - // XTD ... - XTD, - // - // XTAM ... - XTAM, - // - // XSI ... - XSI, - // - // XTSFI ... - XTSFI, - // - // XOBDLH ... - XOBDLH, - // - // XCHMACC ... - XCHMACC, - // - // XCHMACMN ... - XCHMAMN, - // - // XCHMACMX ... - XCHMAMX, -}; - -// -// X5 Provider Inputs ... -class X5ProviderInputs : public XSCBaseProviderInpts -{ - // - // Public ... -public: - // - // Props ... - XTSInputs tsInputs; - XTMInputs tmInputs; - XLHInputs lhInputs; - XTDInputs tdInputs; - XFIInputs fiInputs; - XCTInputs ctInputs; - XCCInputs ccInputs; - XOBDInputs obdInputs; - XAMAInputs amaInputs; - XRSIInputs rsiInputs; - XCHLHInputs chlhInputs; - XCHMAInputs chmaInputs; - - // - // Tools ... - - // - // Validate ... - virtual bool IsValid() - { - // - bool result = false; - - // - result = tsInputs.IsValid(); - if (!result) - { - return result; - } - - result = ctInputs.IsValid(); - if (!result) - { - return result; - } - - // - result = ccInputs.IsValid(); - if (!result) - { - return result; - } - - // - result = tmInputs.IsValid(); - if (!result) - { - return result; - } - - // - result = lhInputs.IsValid(); - if (!result) - { - return result; - } - - // - result = tdInputs.IsValid(); - if (!result) - { - return result; - } - - // - result = fiInputs.IsValid(); - if (!result) - { - return result; - } - - // - result = obdInputs.IsValid(); - if (!result) - { - return result; - } - - // - result = amaInputs.IsValid(); - if (!result) - { - return result; - } - - // - result = rsiInputs.IsValid(); - if (!result) - { - return result; - } - - // - result = chlhInputs.IsValid(); - if (!result) - { - return result; - } - - // - result = chmaInputs.IsValid(); - - // - return result; - } - - // - // Cleanup ... - virtual void Clean() - { - // - tsInputs.Clean(); - ctInputs.Clean(); - ccInputs.Clean(); - tmInputs.Clean(); - lhInputs.Clean(); - tdInputs.Clean(); - fiInputs.Clean(); - obdInputs.Clean(); - amaInputs.Clean(); - rsiInputs.Clean(); - chlhInputs.Clean(); - chmaInputs.Clean(); - } - - // - // Default ... - virtual void Default() - { - // - tsInputs.Default(); - ctInputs.Default(); - ccInputs.Default(); - tmInputs.Default(); - lhInputs.Default(); - tdInputs.Default(); - fiInputs.Default(); - obdInputs.Default(); - amaInputs.Default(); - rsiInputs.Default(); - chlhInputs.Default(); - chmaInputs.Default(); - } - - // - // Max ... - virtual int Max() - { - // - int result = 0; - - // - result = MathMax(lhInputs.Max(), tmInputs.Max()); - - // - result = MathMax(result, tsInputs.Max()); - result = MathMax(result, ctInputs.Max()); - result = MathMax(result, ccInputs.Max()); - result = MathMax(result, tdInputs.Max()); - result = MathMax(result, fiInputs.Max()); - result = MathMax(result, obdInputs.Max()); - result = MathMax(result, amaInputs.Max()); - result = MathMax(result, rsiInputs.Max()); - result = MathMax(result, chlhInputs.Max()); - result = MathMax(result, chmaInputs.Max()); - - // - return result; - } -}; - -// -// XSC5MarketConditionDataCollector ... -class XSC5MarketConditionDataCollector -{ - // - // Public ... -public: - // - // Constructor ... - void XSC5MarketConditionDataCollector() - { - // - XSCDataCollector mBase; - mBase.Clear(); - } - - // - // Cleaning Store ... - void Clear() - { - // - XSCDataCollector mBase; - - // - mBase.Clear(); - } - - // - // Add String Content ... - bool Add(string content) - { - // - bool result = false; - - // - XSCDataCollector mBase; - - // - result = mBase.Add(content); - - // - return result; - } - - // - // Protected ... -protected: - // - // Private ... -private: -}; - -// -// X5 Provider Market Conditions ... -class X5MarketConditions : public XSCBaseProviderMarketConditions -{ - // - // Public ... -public: - // - // Buffers ... - - // - // XTS ... - double tsCurrents[]; - double tsNearests[]; - double tsMediests[]; - double tsFarests[]; - - // - // XFI ... - double fis[]; - - // - // XTD ... - double tdBullishs[]; - double tdBearishs[]; - double tdSignals[]; - - // - // XLH ... - double lhHhs[]; - double lhLls[]; - double lhSignals[]; - - // - // XTM ... - double tms[]; - - // - // XAMA ... - double amas[]; - - // - // XOBD ... - double obds[]; - - // - // XRSI ... - double rsis[]; - - // - // XCHMA ... - double chmaScFasts[]; - double chmaScSlows[]; - double chmaMcFasts[]; - double chmaMcSlows[]; - double chmaLcFasts[]; - double chmaLcSlows[]; - double chmaHotStates[]; - - // - // XCHLH ... - double chlhScHHs[]; - double chlhScLLs[]; - double chlhMcHHs[]; - double chlhMcLLs[]; - double chlhLcHHs[]; - double chlhLcLLs[]; - double chlhHotStates[]; - - // - // Conditional Variables ... - - // - // XTM ... - bool isXTMPeak; - bool isXTMVale; - bool isXTMBullish; - bool isXTMBearish; - bool isXTMNeutural; - bool isXTMEndBullish; - bool isXTMEndBearish; - bool isXTMStartBullish; - bool isXTMStartBearish; - bool isXTMEndBullishByNeutural; - bool isXTMEndBearishByNeutural; - bool isXTMStartBullishAfterNeutural; - bool isXTMStartBearishAfterNeutural; - - // - // XAMA ... - bool isXAMAPeak; - bool isXAMAVale; - bool isXAMABullish; - bool isXAMABearish; - bool isXAMANeutural; - bool isXAMAEndBullish; - bool isXAMAEndBearish; - bool isXAMAStartBullish; - bool isXAMAStartBearish; - bool isXAMAEndBullishByNeutural; - bool isXAMAEndBearishByNeutural; - bool isXAMAStartBullishAfterNeutural; - bool isXAMAStartBearishAfterNeutural; - - // - // XLH ... - bool isXLHHHIncreased; - bool isXLHHHDecreased; - bool isXLHLLIncreased; - bool isXLHLLDecreased; - bool isXLHLowAttachedLL; - bool isXLHHighAttachedHH; - bool isXLHHHSameInLength; - bool isXLHLLSameInLength; - bool isXLHPriceOverSignal; - bool isXLHPriceUnderSignal; - bool isXLHPriceInSignalRange; - bool isXLHPriceCrossedOverSignal; - bool isXLHPriceCrossedUnderSignal; - - // - // XTD ... - bool isXTDSignalPeak; - bool isXTDSignalVale; - bool isXTDBullishPeak; - bool isXTDBullishVale; - bool isXTDBearishPeak; - bool isXTDBearishVale; - bool isXTDBullOverBear; - bool isXTDBullUnderBear; - bool isXTDSignalOverBear; - bool isXTDSignalUnderBear; - bool isXTDBullCrossedOverBear; - bool isXTDBullCrossedUnderBear; - bool isXTDSignalCrossedOverBear; - bool isXTDSignalCrossedUnderBear; - - // - // XFI ... - bool isXFIPeak; - bool isXFIVale; - bool isXFICrossedOverZero; - bool isXFIOverZero; - bool isXFICrossedUnderZero; - bool isXFIUnderZero; - - // - // XTS ... - bool isXTSAllSame; - bool isXTSCurrentMin; - bool isXTSCurrentMax; - bool isXTSCurrentOverFarest; - bool isXTSCurrentOverNearest; - bool isXTSCurrentOverMediest; - bool isXTSCurrentUnderFarest; - bool isXTSCurrentUnderNearest; - bool isXTSCurrentUnderMediest; - bool isXTSCurrentCrossedOverFarest; - bool isXTSCurrentCrossedOverNearest; - bool isXTSCurrentCrossedOverMediest; - bool isXTSCurrentCrossedUnderFarest; - bool isXTSCurrentCrossedUnderNearest; - bool isXTSCurrentCrossedUnderMediest; - - // - // XRSI ... - bool isXRSIPeak; - bool isXRSIVale; - bool isXRSICrossedOverLongExit; - bool isXRSICrossedOverLongEntry; - bool isXRSICrossedUnderShortExit; - bool isXRSICrossedUnderShortEntry; - - // - // XOBD ... - bool isXOBDSwingLow; - bool isXOBDSwingHigh; - - // - // XCHLH ... - // - bool isXCHLHSameHHs; - bool isXCHLHSameLLs; - // - bool isXCHLHSCMCHHSame; - bool isXCHLHSCMCLLSame; - // - bool isXCHLHSCLCHHSame; - bool isXCHLHSCLCLLSame; - // - bool isXCHLHMCLCHHSame; - bool isXCHLHMCLCLLSame; - // - bool isXCHLHMCOnTopOfLC; - bool isXCHLHMCInBottomOfLC; - - // - // XCHMA ... - // - bool isXCHMASCOverMax; - bool isXCHMASCOverMin; - bool isXCHMASCUnderMax; - bool isXCHMASCUnderMin; - // - bool isXCHMASCCrossedOverMax; - bool isXCHMASCCrossedUnderMax; - bool isXCHMASCCrossedOverMin; - bool isXCHMASCCrossedUnderMin; - // - bool isXCHMASCPeak; - bool isXCHMASCVale; - bool isXCHMASCTrendsUp; - bool isXCHMASCTrendsDown; - bool isXCHMASCFastOverSlow; - bool isXCHMASCFastUnderSlow; - bool isXCHMASCFastCrossedOverSlow; - bool isXCHMASCFastCrossedUnderSlow; - // - bool isXCHMAMCPeak; - bool isXCHMAMCVale; - bool isXCHMAMCTrendsUp; - bool isXCHMAMCTrendsDown; - bool isXCHMAMCFastOverSlow; - bool isXCHMAMCFastUnderSlow; - bool isXCHMAMCFastCrossedOverSlow; - bool isXCHMAMCFastCrossedUnderSlow; - // - bool isXCHMALCPeak; - bool isXCHMALCVale; - bool isXCHMALCTrendsUp; - bool isXCHMALCTrendsDown; - bool isXCHMALCFastOverSlow; - bool isXCHMALCFastUnderSlow; - bool isXCHMALCFastCrossedOverSlow; - bool isXCHMALCFastCrossedUnderSlow; - - // - // Tools ... - - // - // Conditions ... - void Clear() - { - // - Clean(bars); - Clean(tsCurrents); - Clean(tsNearests); - Clean(tsMediests); - Clean(tsFarests); - Clean(fis); - Clean(tdBullishs); - Clean(tdBearishs); - Clean(tdSignals); - Clean(lhHhs); - Clean(lhLls); - Clean(lhSignals); - Clean(tms); - Clean(amas); - Clean(obds); - Clean(rsis); - Clean(chmaScFasts); - Clean(chmaScSlows); - Clean(chmaMcFasts); - Clean(chmaMcSlows); - Clean(chmaLcFasts); - Clean(chmaLcSlows); - Clean(chmaHotStates); - Clean(chlhScHHs); - Clean(chlhScLLs); - Clean(chlhMcHHs); - Clean(chlhMcLLs); - Clean(chlhLcHHs); - Clean(chlhLcLLs); - Clean(chlhHotStates); - - // - ArraySetAsSeries(bars, true); - ArraySetAsSeries(tsCurrents, true); - ArraySetAsSeries(tsNearests, true); - ArraySetAsSeries(tsMediests, true); - ArraySetAsSeries(tsFarests, true); - ArraySetAsSeries(fis, true); - ArraySetAsSeries(tdBullishs, true); - ArraySetAsSeries(tdBearishs, true); - ArraySetAsSeries(tdSignals, true); - ArraySetAsSeries(lhHhs, true); - ArraySetAsSeries(lhLls, true); - ArraySetAsSeries(lhSignals, true); - ArraySetAsSeries(tms, true); - ArraySetAsSeries(amas, true); - ArraySetAsSeries(obds, true); - ArraySetAsSeries(rsis, true); - ArraySetAsSeries(chmaScFasts, true); - ArraySetAsSeries(chmaScSlows, true); - ArraySetAsSeries(chmaMcFasts, true); - ArraySetAsSeries(chmaMcSlows, true); - ArraySetAsSeries(chmaLcFasts, true); - ArraySetAsSeries(chmaLcSlows, true); - ArraySetAsSeries(chmaHotStates, true); - ArraySetAsSeries(chlhScHHs, true); - ArraySetAsSeries(chlhScLLs, true); - ArraySetAsSeries(chlhMcHHs, true); - ArraySetAsSeries(chlhMcLLs, true); - ArraySetAsSeries(chlhLcHHs, true); - ArraySetAsSeries(chlhLcLLs, true); - ArraySetAsSeries(chlhHotStates, true); - - // - isXTMPeak = false; - isXTMVale = false; - isXTMBullish = false; - isXTMBearish = false; - isXTMNeutural = false; - isXTMEndBullish = false; - isXTMEndBearish = false; - isXTMStartBullish = false; - isXTMStartBearish = false; - isXTMEndBullishByNeutural = false; - isXTMEndBearishByNeutural = false; - isXTMStartBullishAfterNeutural = false; - isXTMStartBearishAfterNeutural = false; - isXAMAPeak = false; - isXAMAVale = false; - isXAMABullish = false; - isXAMABearish = false; - isXAMANeutural = false; - isXAMAEndBullish = false; - isXAMAEndBearish = false; - isXAMAStartBullish = false; - isXAMAStartBearish = false; - isXAMAEndBullishByNeutural = false; - isXAMAEndBearishByNeutural = false; - isXAMAStartBullishAfterNeutural = false; - isXAMAStartBearishAfterNeutural = false; - isXLHHHIncreased = false; - isXLHHHDecreased = false; - isXLHLLIncreased = false; - isXLHLLDecreased = false; - isXLHLowAttachedLL = false; - isXLHHighAttachedHH = false; - isXLHHHSameInLength = false; - isXLHLLSameInLength = false; - isXLHPriceOverSignal = false; - isXLHPriceUnderSignal = false; - isXLHPriceInSignalRange = false; - isXLHPriceCrossedOverSignal = false; - isXLHPriceCrossedUnderSignal = false; - isXTDSignalPeak = false; - isXTDSignalVale = false; - isXTDBullishPeak = false; - isXTDBullishVale = false; - isXTDBearishPeak = false; - isXTDBearishVale = false; - isXTDBullOverBear = false; - isXTDBullUnderBear = false; - isXTDSignalOverBear = false; - isXTDSignalUnderBear = false; - isXTDBullCrossedOverBear = false; - isXTDBullCrossedUnderBear = false; - isXTDSignalCrossedOverBear = false; - isXTDSignalCrossedUnderBear = false; - isXFIPeak = false; - isXFIVale = false; - isXFICrossedOverZero = false; - isXFIOverZero = false; - isXFICrossedUnderZero = false; - isXFIUnderZero = false; - isXTSAllSame = false; - isXTSCurrentMin = false; - isXTSCurrentMax = false; - isXTSCurrentOverFarest = false; - isXTSCurrentOverNearest = false; - isXTSCurrentOverMediest = false; - isXTSCurrentUnderFarest = false; - isXTSCurrentUnderNearest = false; - isXTSCurrentUnderMediest = false; - isXTSCurrentCrossedOverFarest = false; - isXTSCurrentCrossedOverNearest = false; - isXTSCurrentCrossedOverMediest = false; - isXTSCurrentCrossedUnderFarest = false; - isXTSCurrentCrossedUnderNearest = false; - isXTSCurrentCrossedUnderMediest = false; - isXRSIPeak = false; - isXRSIVale = false; - isXRSICrossedOverLongExit = false; - isXRSICrossedOverLongEntry = false; - isXRSICrossedUnderShortExit = false; - isXRSICrossedUnderShortEntry = false; - isXOBDSwingLow = false; - isXOBDSwingHigh = false; - isXCHLHSameHHs = false; - isXCHLHSameLLs = false; - isXCHLHSCMCHHSame = false; - isXCHLHSCMCLLSame = false; - isXCHLHSCLCHHSame = false; - isXCHLHSCLCLLSame = false; - isXCHLHMCLCHHSame = false; - isXCHLHMCLCLLSame = false; - isXCHLHMCOnTopOfLC = false; - isXCHLHMCInBottomOfLC = false; - isXCHMASCOverMax = false; - isXCHMASCOverMin = false; - isXCHMASCUnderMax = false; - isXCHMASCUnderMin = false; - isXCHMASCCrossedOverMax = false; - isXCHMASCCrossedUnderMax = false; - isXCHMASCCrossedOverMin = false; - isXCHMASCCrossedUnderMin = false; - isXCHMASCPeak = false; - isXCHMASCVale = false; - isXCHMASCTrendsUp = false; - isXCHMASCTrendsDown = false; - isXCHMASCFastOverSlow = false; - isXCHMASCFastUnderSlow = false; - isXCHMASCFastCrossedOverSlow = false; - isXCHMASCFastCrossedUnderSlow = false; - isXCHMAMCPeak = false; - isXCHMAMCVale = false; - isXCHMAMCTrendsUp = false; - isXCHMAMCTrendsDown = false; - isXCHMAMCFastOverSlow = false; - isXCHMAMCFastUnderSlow = false; - isXCHMAMCFastCrossedOverSlow = false; - isXCHMAMCFastCrossedUnderSlow = false; - isXCHMALCPeak = false; - isXCHMALCVale = false; - isXCHMALCTrendsUp = false; - isXCHMALCTrendsDown = false; - isXCHMALCFastOverSlow = false; - isXCHMALCFastUnderSlow = false; - isXCHMALCFastCrossedOverSlow = false; - isXCHMALCFastCrossedUnderSlow = false; - } - - // - // Generate Score ... - virtual void GenerateScore( - double &bullishScore, // Bullish Score - double &bearishScore, // Bearish Score - double multiplier = 1 // Score Multiplier - ) - { - // - bullishScore = 0; - bearishScore = 0; - - // - // Normalize Multiplier ... - if (multiplier <= 0) - { - multiplier = 1; - } - - // - double bullScore = 0; - double bearScore = 0; - - // - // Calculate Scores ... - - // - // XTM ... - - // - if (isXTMPeak) - { - // - bullScore--; - bearScore++; - } - - // - if (isXTMVale) - { - // - bullScore++; - bearScore--; - } - - // - if (isXTMBullish) - { - bullScore++; - } - - // - if (isXTMBearish) - { - bearScore++; - } - - // - if (isXTMNeutural) - { - } - - // - if (isXTMEndBullish) - { - bearScore++; - } - - // - if (isXTMEndBearish) - { - bullScore++; - } - - // - if (isXTMStartBullish) - { - bullScore++; - } - - // - if (isXTMStartBearish) - { - bearScore++; - } - - // - if (isXTMEndBullishByNeutural) - { - bearScore++; - } - - // - if (isXTMEndBearishByNeutural) - { - bullScore++; - } - - // - if (isXTMStartBullishAfterNeutural) - { - bullScore++; - } - - // - if (isXTMStartBearishAfterNeutural) - { - bearScore++; - } - - // - // XAMA ... - - // - if (isXAMAPeak) - { - // - bullScore--; - bearScore++; - } - - // - if (isXAMAVale) - { - // - bullScore++; - bearScore--; - } - - // - if (isXAMABullish) - { - bullScore++; - } - - // - if (isXAMABearish) - { - bearScore++; - } - - // - if (isXAMANeutural) - { - } - - // - if (isXAMAEndBullish) - { - bearScore++; - } - - // - if (isXAMAEndBearish) - { - bullScore++; - } - - // - if (isXAMAStartBullish) - { - bullScore++; - } - - // - if (isXAMAStartBearish) - { - bearScore++; - } - - // - if (isXAMAEndBullishByNeutural) - { - bearScore++; - } - - // - if (isXAMAEndBearishByNeutural) - { - bullScore++; - } - - // - if (isXAMAStartBullishAfterNeutural) - { - bullScore++; - } - - // - if (isXAMAStartBearishAfterNeutural) - { - bearScore++; - } - - // - // XLH ... - - // - if (isXLHHHIncreased) - { - // - bullScore--; - bearScore++; - } - - // - if (isXLHHHDecreased) - { - // - bullScore++; - bearScore--; - } - - // - if (isXLHLLIncreased) - { - // - bullScore++; - bearScore--; - } - - // - if (isXLHLLDecreased) - { - // - bullScore--; - bearScore++; - } - - // - if (isXLHLowAttachedLL) - { - // - bullScore++; - bearScore--; - } - - // - if (isXLHHighAttachedHH) - { - // - bullScore--; - bearScore++; - } - - // - if (isXLHHHSameInLength) - { - } - - // - if (isXLHLLSameInLength) - { - } - - // - if (isXLHPriceOverSignal) - { - bullScore++; - } - - // - if (isXLHPriceUnderSignal) - { - bearScore++; - } - - // - if (isXLHPriceInSignalRange) - { - } - - // - if (isXLHPriceCrossedOverSignal) - { - // - bullScore++; - bearScore--; - } - - // - if (isXLHPriceCrossedUnderSignal) - { - // - bullScore--; - bearScore++; - } - - // - // XTD ... - - // - if (isXTDSignalPeak) - { - // - bullScore--; - bearScore++; - } - - // - if (isXTDSignalVale) - { - // - bullScore++; - bearScore--; - } - - // - if (isXTDBullishPeak) - { - // - bullScore--; - bearScore++; - } - - // - if (isXTDBullishVale) - { - // - bullScore++; - bearScore--; - } - - // - if (isXTDBearishPeak) - { - // - bullScore++; - bearScore--; - } - - // - if (isXTDBearishVale) - { - // - bullScore--; - bearScore++; - } - - // - if (isXTDBullOverBear) - { - bullScore++; - } - - // - if (isXTDBullUnderBear) - { - bearScore++; - } - - // - if (isXTDSignalOverBear) - { - bullScore++; - } - - // - if (isXTDSignalUnderBear) - { - bearScore++; - } - - // - if (isXTDBullCrossedOverBear) - { - // - bullScore++; - bearScore--; - } - - // - if (isXTDBullCrossedUnderBear) - { - // - bullScore--; - bearScore++; - } - - // - if (isXTDSignalCrossedOverBear) - { - // - bullScore++; - bearScore--; - } - - // - if (isXTDSignalCrossedUnderBear) - { - // - bullScore--; - bearScore++; - } - - // - // XFI ... - - // - if (isXFIPeak) - { - // - bullScore--; - bearScore++; - } - - // - if (isXFIVale) - { - // - bullScore++; - bearScore--; - } - - // - if (isXFICrossedOverZero) - { - // - bullScore++; - bearScore--; - } - - // - if (isXFIOverZero) - { - bullScore++; - } - - // - if (isXFICrossedUnderZero) - { - // - bullScore--; - bearScore++; - } - - // - if (isXFIUnderZero) - { - bearScore++; - } - - // - // XTS ... - - // - if (isXTSAllSame) - { - } - - // - if (isXTSCurrentMin) - { - // - bullScore++; - bearScore--; - } - - // - if (isXTSCurrentMax) - { - // - bullScore--; - bearScore++; - } - - // - if (isXTSCurrentOverFarest) - { - bullScore--; - } - - // - if (isXTSCurrentOverNearest) - { - bullScore--; - } - - // - if (isXTSCurrentOverMediest) - { - bullScore--; - } - - // - if (isXTSCurrentUnderFarest) - { - bearScore--; - } - - // - if (isXTSCurrentUnderNearest) - { - bearScore--; - } - - // - if (isXTSCurrentUnderMediest) - { - bearScore--; - } - - // - if (isXTSCurrentCrossedOverFarest) - { - // - bullScore++; - bearScore--; - } - - // - if (isXTSCurrentCrossedOverNearest) - { - // - bullScore++; - bearScore--; - } - - // - if (isXTSCurrentCrossedOverMediest) - { - // - bullScore++; - bearScore--; - } - - // - if (isXTSCurrentCrossedUnderFarest) - { - // - bullScore--; - bearScore++; - } - - // - if (isXTSCurrentCrossedUnderNearest) - { - // - bullScore--; - bearScore++; - } - - // - if (isXTSCurrentCrossedUnderMediest) - { - // - bullScore--; - bearScore++; - } - - // - // XSI ... - - // - if (isXRSIPeak) - { - // - bullScore--; - bearScore++; - } - - // - if (isXRSIVale) - { - // - bullScore++; - bearScore--; - } - - // - if (isXRSICrossedOverLongExit) - { - // - bullScore--; - bearScore++; - } - - // - if (isXRSICrossedOverLongEntry) - { - // - bullScore++; - bearScore--; - } - - // - if (isXRSICrossedUnderShortExit) - { - // - bullScore++; - bearScore--; - } - - // - if (isXRSICrossedUnderShortEntry) - { - // - bullScore--; - bearScore++; - } - - // - // XOBD ... - - // - if (isXOBDSwingLow) - { - bullScore++; - } - - // - if (isXOBDSwingHigh) - { - bearScore++; - } - - // - // XCHLH ... - - // - if (isXCHLHSameHHs) - { - bearScore++; - } - - // - if (isXCHLHSameLLs) - { - bullScore++; - } - - // - if (isXCHLHSCMCHHSame) - { - bearScore++; - } - - // - if (isXCHLHSCMCLLSame) - { - bullScore++; - } - - // - if (isXCHLHSCLCHHSame) - { - bearScore++; - } - - // - if (isXCHLHSCLCLLSame) - { - bullScore++; - } - - // - if (isXCHLHMCLCHHSame) - { - bearScore++; - } - - // - if (isXCHLHMCLCLLSame) - { - bullScore++; - } - - // - if (isXCHLHMCOnTopOfLC) - { - } - - // - if (isXCHLHMCInBottomOfLC) - { - } - - // - // XCHMA ... - - // - if (isXCHMASCOverMax) - { - // - bullScore--; - bearScore++; - } - - // - if (isXCHMASCOverMin) - { - // - bullScore++; - bearScore--; - } - - // - if (isXCHMASCUnderMax) - { - // - bullScore--; - bearScore++; - } - - // - if (isXCHMASCUnderMin) - { - // - bullScore++; - bearScore--; - } - - // - if (isXCHMASCCrossedOverMax) - { - // - bearScore--; - bearScore++; - } - - // - if (isXCHMASCCrossedUnderMax) - { - // - bullScore--; - bearScore++; - } - - // - if (isXCHMASCCrossedOverMin) - { - // - bullScore++; - bearScore--; - } - - // - if (isXCHMASCCrossedUnderMin) - { - // - bullScore++; - bearScore--; - } - - // - if (isXCHMASCPeak) - { - // - bullScore--; - bearScore++; - } - - // - if (isXCHMASCVale) - { - // - bullScore++; - bearScore--; - } - - // - if (isXCHMASCTrendsUp) - { - // - if (isXCHMASCFastOverSlow) - { - // - bullScore++; - bearScore--; - } - - // - if (isXCHMASCFastUnderSlow) - { - // - bullScore--; - bearScore++; - } - } - - // - if (isXCHMASCTrendsDown) - { - // - if (isXCHMASCFastOverSlow) - { - // - bullScore--; - bearScore++; - } - - // - if (isXCHMASCFastUnderSlow) - { - // - bullScore++; - bearScore--; - } - } - - // - if (isXCHMASCFastOverSlow) - { - bearScore++; - } - - // - if (isXCHMASCFastUnderSlow) - { - bearScore++; - } - - // - if (isXCHMASCFastCrossedOverSlow) - { - // - bullScore++; - bearScore--; - } - - // - if (isXCHMASCFastCrossedUnderSlow) - { - // - bullScore--; - bearScore++; - } - - // - if (isXCHMAMCPeak) - { - // - bullScore--; - bearScore++; - } - - // - if (isXCHMAMCVale) - { - // - bullScore++; - bearScore--; - } - - // - if (isXCHMAMCTrendsUp) - { - // - if (isXCHMAMCFastOverSlow) - { - // - bullScore++; - bearScore--; - } - - // - if (isXCHMAMCFastUnderSlow) - { - // - bullScore--; - bearScore++; - } - } - - // - if (isXCHMAMCTrendsDown) - { - // - if (isXCHMAMCFastOverSlow) - { - // - bullScore--; - bearScore++; - } - - // - if (isXCHMAMCFastUnderSlow) - { - // - bullScore++; - bearScore--; - } - } - - // - if (isXCHMAMCFastOverSlow) - { - bullScore++; - } - - // - if (isXCHMAMCFastUnderSlow) - { - bearScore++; - } - - // - if (isXCHMAMCFastCrossedOverSlow) - { - // - bullScore++; - bearScore--; - } - - // - if (isXCHMAMCFastCrossedUnderSlow) - { - // - bullScore--; - bearScore++; - } - - // - if (isXCHMALCPeak) - { - // - bullScore--; - bearScore++; - } - - // - if (isXCHMALCVale) - { - // - bullScore++; - bearScore--; - } - - // - if (isXCHMALCTrendsUp) - { - // - if (isXCHMALCFastOverSlow) - { - // - bullScore++; - bearScore--; - } - - // - if (isXCHMALCFastUnderSlow) - { - // - bullScore--; - bearScore++; - } - } - - // - if (isXCHMALCTrendsDown) - { - // - if (isXCHMALCFastOverSlow) - { - // - bullScore--; - bearScore++; - } - - // - if (isXCHMALCFastUnderSlow) - { - // - bullScore++; - bearScore--; - } - } - - // - if (isXCHMALCFastOverSlow) - { - bullScore++; - } - - // - if (isXCHMALCFastUnderSlow) - { - bearScore++; - } - - // - if (isXCHMALCFastCrossedOverSlow) - { - // - bullScore++; - bearScore--; - } - - // - if (isXCHMALCFastCrossedUnderSlow) - { - // - bullScore--; - bearScore++; - } - - // - // Prepare Final Result ... - - // - bullishScore = bullScore * multiplier; - bearishScore = bearScore * multiplier; - } - - // - // Generate Summary ... - virtual string GenerateSummary( - const bool onlySummary = false, // Only Generate Conditions Summary - double multiplier = 1, // Score Multiplier - const string separator = "\n", // Separator - const bool ignoreFalseConditions = true // Ignore False Conditions - ) - { - // - string result = NULL; - - // - result = GenerateSummaryBody( - onlySummary, - multiplier, - separator, - ignoreFalseConditions - // - ); - - // - // Generating Full Result by Combining parts ... - result = - // - "[" + GetToken() + "]" + separator + - "-----------------------------" + separator + - result + - "" - // - ; - - // - return result; - } - - // - string GenerateSummaryBody( - const bool onlySummary = false, // Only Generate Conditions Summary - double multiplier = 1, // Score Multiplier - const string separator = "\n", // Separator - const bool ignoreFalseConditions = true // Ignore False Conditions - ) - { - // - string result = NULL; - - // - double bullScore = 0; - double bearScore = 0; - GenerateScore( - bullScore, - bearScore, - multiplier // - ); - - // - // Common ... - string commonStr = - // - "Commons: " + separator + - "-----------------------------" + separator + - "Time: " + ToString(TimeCurrent()) + separator + - "-----------" + separator + - "Scores: " + separator + - "-----------" + separator + - "Bullish: " + ToString(bullScore) + separator + - "Bearish: " + ToString(bearScore) + separator + - "-----------------------------" + separator + - // - // TODO: Add Scores Later ... - separator + - "" - // - ; - - // - // XOBD ... - string obdStr = - // - ToString("isXOBDSwingLow", isXOBDSwingLow, ignoreFalseConditions) + - ToString("isXOBDSwingHigh", isXOBDSwingHigh, ignoreFalseConditions) + - "" - // - ; - obdStr = SetLabel("XOBD: ", obdStr, separator); - - // - // ToString("", , ignoreFalseConditions) + - - // - // XFI ... - string fiStr = - // - ToString("isXFIPeak", isXFIPeak, ignoreFalseConditions) + - ToString("isXFIVale", isXFIVale, ignoreFalseConditions) + - ToString("isXFICrossedOverZero", isXFICrossedOverZero, ignoreFalseConditions) + - ToString("isXFIOverZero", isXFIOverZero, ignoreFalseConditions) + - ToString("isXFICrossedUnderZero", isXFICrossedUnderZero, ignoreFalseConditions) + - ToString("isXFIUnderZero", isXFIUnderZero, ignoreFalseConditions) + - "" - // - ; - fiStr = SetLabel("XFI: ", fiStr, separator); - - // - // XRSI ... - string rsiStr = - // - ToString("isXRSIPeak", isXRSIPeak, ignoreFalseConditions) + - ToString("isXRSIVale", isXRSIVale, ignoreFalseConditions) + - ToString("isXRSICrossedOverLongExit", isXRSICrossedOverLongExit, ignoreFalseConditions) + - ToString("isXRSICrossedOverLongEntry", isXRSICrossedOverLongEntry, ignoreFalseConditions) + - ToString("isXRSICrossedUnderShortExit", isXRSICrossedUnderShortExit, ignoreFalseConditions) + - ToString("isXRSICrossedUnderShortEntry", isXRSICrossedUnderShortEntry, ignoreFalseConditions) + - "" - // - ; - rsiStr = SetLabel("XRSI: ", rsiStr, separator); - - // - // XTM ... - string tmStr = - // - ToString("isXTMPeak", isXTMPeak, ignoreFalseConditions) + - ToString("isXTMVale", isXTMVale, ignoreFalseConditions) + - ToString("isXTMBullish", isXTMBullish, ignoreFalseConditions) + - ToString("isXTMBearish", isXTMBearish, ignoreFalseConditions) + - ToString("isXTMNeutural", isXTMNeutural, ignoreFalseConditions) + - ToString("isXTMEndBullish", isXTMEndBullish, ignoreFalseConditions) + - ToString("isXTMEndBearish", isXTMEndBearish, ignoreFalseConditions) + - ToString("isXTMStartBullish", isXTMStartBullish, ignoreFalseConditions) + - ToString("isXTMStartBearish", isXTMStartBearish, ignoreFalseConditions) + - ToString("isXTMEndBullishByNeutural", isXTMEndBullishByNeutural, ignoreFalseConditions) + - ToString("isXTMEndBearishByNeutural", isXTMEndBearishByNeutural, ignoreFalseConditions) + - ToString("isXTMStartBullishAfterNeutural", isXTMStartBullishAfterNeutural, ignoreFalseConditions) + - ToString("isXTMStartBearishAfterNeutural", isXTMStartBearishAfterNeutural, ignoreFalseConditions) + - "" - // - ; - tmStr = SetLabel("XTM: ", tmStr, separator); - - // - // XAMA ... - string amaStr = - // - ToString("isXAMAPeak", isXAMAPeak, ignoreFalseConditions) + - ToString("isXAMAVale", isXAMAVale, ignoreFalseConditions) + - ToString("isXAMABullish", isXAMABullish, ignoreFalseConditions) + - ToString("isXAMABearish", isXAMABearish, ignoreFalseConditions) + - ToString("isXAMANeutural", isXAMANeutural, ignoreFalseConditions) + - ToString("isXAMAEndBullish", isXAMAEndBullish, ignoreFalseConditions) + - ToString("isXAMAEndBearish", isXAMAEndBearish, ignoreFalseConditions) + - ToString("isXAMAStartBullish", isXAMAStartBullish, ignoreFalseConditions) + - ToString("isXAMAStartBearish", isXAMAStartBearish, ignoreFalseConditions) + - ToString("isXAMAEndBullishByNeutural", isXAMAEndBullishByNeutural, ignoreFalseConditions) + - ToString("isXAMAEndBearishByNeutural", isXAMAEndBearishByNeutural, ignoreFalseConditions) + - ToString("isXAMAStartBullishAfterNeutural", isXAMAStartBullishAfterNeutural, ignoreFalseConditions) + - ToString("isXAMAStartBearishAfterNeutural", isXAMAStartBearishAfterNeutural, ignoreFalseConditions) + - "" - // - ; - amaStr = SetLabel("XAMA: ", amaStr, separator); - - // - // XLH ... - string lhStr = - // - ToString("isXLHHHIncreased", isXLHHHIncreased, ignoreFalseConditions) + - ToString("isXLHHHDecreased", isXLHHHDecreased, ignoreFalseConditions) + - ToString("isXLHLLIncreased", isXLHLLIncreased, ignoreFalseConditions) + - ToString("isXLHLLDecreased", isXLHLLDecreased, ignoreFalseConditions) + - ToString("isXLHLowAttachedLL", isXLHLowAttachedLL, ignoreFalseConditions) + - ToString("isXLHHighAttachedHH", isXLHHighAttachedHH, ignoreFalseConditions) + - ToString("isXLHHHSameInLength", isXLHHHSameInLength, ignoreFalseConditions) + - ToString("isXLHLLSameInLength", isXLHLLSameInLength, ignoreFalseConditions) + - ToString("isXLHPriceOverSignal", isXLHPriceOverSignal, ignoreFalseConditions) + - ToString("isXLHPriceUnderSignal", isXLHPriceUnderSignal, ignoreFalseConditions) + - ToString("isXLHPriceInSignalRange", isXLHPriceInSignalRange, ignoreFalseConditions) + - ToString("isXLHPriceCrossedOverSignal", isXLHPriceCrossedOverSignal, ignoreFalseConditions) + - ToString("isXLHPriceCrossedUnderSignal", isXLHPriceCrossedUnderSignal, ignoreFalseConditions) + - "" - // - ; - lhStr = SetLabel("XLH: ", lhStr, separator); - - // - // XTD ... - string tdStr = - // - ToString("isXTDSignalPeak", isXTDSignalPeak, ignoreFalseConditions) + - ToString("isXTDSignalVale", isXTDSignalVale, ignoreFalseConditions) + - ToString("isXTDBullishPeak", isXTDBullishPeak, ignoreFalseConditions) + - ToString("isXTDBullishVale", isXTDBullishVale, ignoreFalseConditions) + - ToString("isXTDBearishPeak", isXTDBearishPeak, ignoreFalseConditions) + - ToString("isXTDBearishVale", isXTDBearishVale, ignoreFalseConditions) + - ToString("isXTDBullOverBear", isXTDBullOverBear, ignoreFalseConditions) + - ToString("isXTDBullUnderBear", isXTDBullUnderBear, ignoreFalseConditions) + - ToString("isXTDSignalOverBear", isXTDSignalOverBear, ignoreFalseConditions) + - ToString("isXTDSignalUnderBear", isXTDSignalUnderBear, ignoreFalseConditions) + - ToString("isXTDBullCrossedOverBear", isXTDBullCrossedOverBear, ignoreFalseConditions) + - ToString("isXTDBullCrossedUnderBear", isXTDBullCrossedUnderBear, ignoreFalseConditions) + - ToString("isXTDSignalCrossedOverBear", isXTDSignalCrossedOverBear, ignoreFalseConditions) + - ToString("isXTDSignalCrossedUnderBear", isXTDSignalCrossedUnderBear, ignoreFalseConditions) + - "" - // - ; - tdStr = SetLabel("XTD: ", tdStr, separator); - - // - // XTS ... - string tsStr = - // - ToString("isXTSAllSame", isXTSAllSame, ignoreFalseConditions) + - ToString("isXTSCurrentMin", isXTSCurrentMin, ignoreFalseConditions) + - ToString("isXTSCurrentMax", isXTSCurrentMax, ignoreFalseConditions) + - ToString("isXTSCurrentOverFarest", isXTSCurrentOverFarest, ignoreFalseConditions) + - ToString("isXTSCurrentOverNearest", isXTSCurrentOverNearest, ignoreFalseConditions) + - ToString("isXTSCurrentOverMediest", isXTSCurrentOverMediest, ignoreFalseConditions) + - ToString("isXTSCurrentUnderFarest", isXTSCurrentUnderFarest, ignoreFalseConditions) + - ToString("isXTSCurrentUnderNearest", isXTSCurrentUnderNearest, ignoreFalseConditions) + - ToString("isXTSCurrentUnderMediest", isXTSCurrentUnderMediest, ignoreFalseConditions) + - ToString("isXTSCurrentCrossedOverFarest", isXTSCurrentCrossedOverFarest, ignoreFalseConditions) + - ToString("isXTSCurrentCrossedOverNearest", isXTSCurrentCrossedOverNearest, ignoreFalseConditions) + - ToString("isXTSCurrentCrossedOverMediest", isXTSCurrentCrossedOverMediest, ignoreFalseConditions) + - ToString("isXTSCurrentCrossedUnderFarest", isXTSCurrentCrossedUnderFarest, ignoreFalseConditions) + - ToString("isXTSCurrentCrossedUnderNearest", isXTSCurrentCrossedUnderNearest, ignoreFalseConditions) + - ToString("isXTSCurrentCrossedUnderMediest", isXTSCurrentCrossedUnderMediest, ignoreFalseConditions) + - "" - // - ; - tsStr = SetLabel("XTS: ", tsStr, separator); - - // - // XCHLH ... - string chlhStr = - // - ToString("isXCHLHSameHHs", isXCHLHSameHHs, ignoreFalseConditions) + - ToString("isXCHLHSameLLs", isXCHLHSameLLs, ignoreFalseConditions) + - ToString("isXCHLHSCMCHHSame", isXCHLHSCMCHHSame, ignoreFalseConditions) + - ToString("isXCHLHSCMCLLSame", isXCHLHSCMCLLSame, ignoreFalseConditions) + - ToString("isXCHLHSCLCHHSame", isXCHLHSCLCHHSame, ignoreFalseConditions) + - ToString("isXCHLHSCLCLLSame", isXCHLHSCLCLLSame, ignoreFalseConditions) + - ToString("isXCHLHMCLCHHSame", isXCHLHMCLCHHSame, ignoreFalseConditions) + - ToString("isXCHLHMCLCLLSame", isXCHLHMCLCLLSame, ignoreFalseConditions) + - ToString("isXCHLHMCOnTopOfLC", isXCHLHMCOnTopOfLC, ignoreFalseConditions) + - ToString("isXCHLHMCInBottomOfLC", isXCHLHMCInBottomOfLC, ignoreFalseConditions) + - "" - // - ; - chlhStr = SetLabel("XCHLH: ", chlhStr, separator); - - // - // XCHMA ... - string chmaStr = - // - ToString("isXCHMASCOverMax", isXCHMASCOverMax, ignoreFalseConditions) + - ToString("isXCHMASCOverMin", isXCHMASCOverMin, ignoreFalseConditions) + - ToString("isXCHMASCUnderMax", isXCHMASCUnderMax, ignoreFalseConditions) + - ToString("isXCHMASCUnderMin", isXCHMASCUnderMin, ignoreFalseConditions) + - ToString("isXCHMASCCrossedOverMax", isXCHMASCCrossedOverMax, ignoreFalseConditions) + - ToString("isXCHMASCCrossedUnderMax", isXCHMASCCrossedUnderMax, ignoreFalseConditions) + - ToString("isXCHMASCCrossedOverMin", isXCHMASCCrossedOverMin, ignoreFalseConditions) + - ToString("isXCHMASCCrossedUnderMin", isXCHMASCCrossedUnderMin, ignoreFalseConditions) + - ToString("isXCHMASCPeak", isXCHMASCPeak, ignoreFalseConditions) + - ToString("isXCHMASCVale", isXCHMASCVale, ignoreFalseConditions) + - ToString("isXCHMASCTrendsUp", isXCHMASCTrendsUp, ignoreFalseConditions) + - ToString("isXCHMASCTrendsDown", isXCHMASCTrendsDown, ignoreFalseConditions) + - ToString("isXCHMASCFastOverSlow", isXCHMASCFastOverSlow, ignoreFalseConditions) + - ToString("isXCHMASCFastUnderSlow", isXCHMASCFastUnderSlow, ignoreFalseConditions) + - ToString("isXCHMASCFastCrossedOverSlow", isXCHMASCFastCrossedOverSlow, ignoreFalseConditions) + - ToString("isXCHMASCFastCrossedUnderSlow", isXCHMASCFastCrossedUnderSlow, ignoreFalseConditions) + - ToString("isXCHMAMCPeak", isXCHMAMCPeak, ignoreFalseConditions) + - ToString("isXCHMAMCVale", isXCHMAMCVale, ignoreFalseConditions) + - ToString("isXCHMAMCTrendsUp", isXCHMAMCTrendsUp, ignoreFalseConditions) + - ToString("isXCHMAMCTrendsDown", isXCHMAMCTrendsDown, ignoreFalseConditions) + - ToString("isXCHMAMCFastOverSlow", isXCHMAMCFastOverSlow, ignoreFalseConditions) + - ToString("isXCHMAMCFastUnderSlow", isXCHMAMCFastUnderSlow, ignoreFalseConditions) + - ToString("isXCHMAMCFastCrossedOverSlow", isXCHMAMCFastCrossedOverSlow, ignoreFalseConditions) + - ToString("isXCHMAMCFastCrossedUnderSlow", isXCHMAMCFastCrossedUnderSlow, ignoreFalseConditions) + - ToString("isXCHMALCPeak", isXCHMALCPeak, ignoreFalseConditions) + - ToString("isXCHMALCVale", isXCHMALCVale, ignoreFalseConditions) + - ToString("isXCHMALCTrendsUp", isXCHMALCTrendsUp, ignoreFalseConditions) + - ToString("isXCHMALCTrendsDown", isXCHMALCTrendsDown, ignoreFalseConditions) + - ToString("isXCHMALCFastOverSlow", isXCHMALCFastOverSlow, ignoreFalseConditions) + - ToString("isXCHMALCFastUnderSlow", isXCHMALCFastUnderSlow, ignoreFalseConditions) + - ToString("isXCHMALCFastCrossedOverSlow", isXCHMALCFastCrossedOverSlow, ignoreFalseConditions) + - ToString("isXCHMALCFastCrossedUnderSlow", isXCHMALCFastCrossedUnderSlow, ignoreFalseConditions) + - "" - // - ; - chmaStr = SetLabel("XCHMA: ", chmaStr, separator); - - // - // Generating Full Result by Combining parts ... - result = - // - commonStr + - (onlySummary - ? "" - : obdStr + - fiStr + - rsiStr + - tmStr + - amaStr + - lhStr + - tdStr + - tsStr + - chlhStr + - chmaStr // - ) + - "" - // - ; - - // - return result; - } - - // - string GenerateSummary( - string provided, // Additional Info about Type, Provider and Symbol - const bool onlySummary = false, // Only Generate Conditions Summary - double multiplier = 1, // Score Multiplier - const string separator = "\n", // Separator - const bool ignoreFalseConditions = true // Ignore False Conditions - ) - { - // - string result = NULL; - - // - result = GenerateSummaryBody( - onlySummary, - multiplier, - separator, - ignoreFalseConditions - // - ); - - // - // Generating Full Result by Combining parts ... - result = - // - "[" + GetToken() + "]" + separator + - provided + separator + - "-----------------------------" + separator + - result + - "" - // - ; - - // - return result; - } - - // - // For Data Collector ... - string GetToken() - { - return GetSpecificToken(this); - } - bool IsModelValid() - { - return false; - } - string ToModelString() - { - return NULL; - } - bool ParseModel(string content) - { - return false; - } - int FindIndex(X5MarketConditions &items[]) - { - return -1; - } -}; - -// -// Class ... - -// -// X5 Provider Class ... -class XSCX5Provider : public XSCBaseProvider -{ - // - // Public ... -public: - // - // Props ... - XSCXTSHelper *tsHelper; - XSCXFIHelper *fiHelper; - XSCXTDHelper *tdHelper; - XSCXLHHelper *lhHelper; - XSCXTMHelper *tmHelper; - XSCXCCHelper *ccHelper; - XSCXCTHelper *ctHelper; - XSCXOBDHelper *obdHelper; - XSCXRSIHelper *rsiHelper; - XSCXAMAHelper *amaHelper; - XSCXCHMAHelper *chmaHelper; - XSCXCHLHHelper *chlhHelper; - - // - // Constructor ... - XSCX5Provider( - string symbol, // Trading Symbol - ENUM_TIMEFRAMES period, // Trading Period - double staticVolume // Static Volume for Positions - ) : XSCBaseProvider(symbol, period, staticVolume) - { - // - tsHelper = new XSCXTSHelper(); - fiHelper = new XSCXFIHelper(); - tdHelper = new XSCXTDHelper(); - lhHelper = new XSCXLHHelper(); - tmHelper = new XSCXTMHelper(); - ccHelper = new XSCXCCHelper(); - ctHelper = new XSCXCTHelper(); - obdHelper = new XSCXOBDHelper(); - rsiHelper = new XSCXRSIHelper(); - amaHelper = new XSCXAMAHelper(); - chmaHelper = new XSCXCHMAHelper(); - chlhHelper = new XSCXCHLHHelper(); - - // - mNumberOfItems = 15; - } - - // - // Properties Gettr(s) / Setter(s) ... - - // - // Overrides ... - - // - // DeInit all Requirements ... - void DeInit() override - { - // - delete tsHelper; - delete fiHelper; - delete tdHelper; - delete lhHelper; - delete tmHelper; - delete ccHelper; - delete ctHelper; - delete obdHelper; - delete rsiHelper; - delete amaHelper; - delete chmaHelper; - delete chlhHelper; - } - - // - // Functions ... - - // - // Init all Requirements ... - bool Init(X5ProviderInputs &inputs) - { - // - bool result = false; - - // - // Validate ... - result = inputs.IsValid(); - if (!result) - { - return result; - } - - // - mInputs = inputs; - - // - string mSymbol = GetSymbol(); - ENUM_TIMEFRAMES mPeriod = GetPeriod(); - - // - result = tsHelper - .Init( - mSymbol, - mPeriod, - mInputs.tsInputs - // - ); - if (!result) - { - return result; - } - - // - result = fiHelper - .Init( - mSymbol, - mPeriod, - mInputs.fiInputs - // - ); - if (!result) - { - return result; - } - - // - result = tdHelper - .Init( - mSymbol, - mPeriod, - mInputs.tdInputs - // - ); - if (!result) - { - return result; - } - - // - result = lhHelper - .Init( - mSymbol, - mPeriod, - mInputs.lhInputs - // - ); - if (!result) - { - return result; - } - - // - result = tmHelper - .Init( - mSymbol, - mPeriod, - mInputs.tmInputs - // - ); - if (!result) - { - return result; - } - - // - result = ccHelper - .Init( - mSymbol, - mPeriod, - mInputs.ccInputs - // - ); - if (!result) - { - return result; - } - - // - result = ctHelper - .Init( - mSymbol, - mPeriod, - mInputs.ctInputs - // - ); - if (!result) - { - return result; - } - - // - result = obdHelper - .Init( - mSymbol, - mPeriod, - mInputs.obdInputs - // - ); - if (!result) - { - return result; - } - - // - result = rsiHelper - .Init( - mSymbol, - mPeriod, - mInputs.rsiInputs - // - ); - if (!result) - { - return result; - } - - // - result = amaHelper - .Init( - mSymbol, - mPeriod, - mInputs.amaInputs - // - ); - if (!result) - { - return result; - } - - // - result = chmaHelper - .Init( - mSymbol, - mPeriod, - mInputs.chmaInputs - // - ); - if (!result) - { - return result; - } - - // - result = chlhHelper - .Init( - mSymbol, - mPeriod, - mInputs.chlhInputs - // - ); - - // - return result; - } - - // - // Set Default Position's Type ... - // Enable / Disable Long (Buy), Short (Sell) ... - void SetSignalTypeState( - ENUM_POSITION_TYPE type, // Which types are Signals be Targetted - bool state // Which State is going to Set - ) - { - // - if (IsLong(type)) - { - mIsLongEnable = state; - } - else - { - mIsShortEnable = state; - } - } - - // - // Set Signal Providers ... - void SetSignalProviderState( - ENUM_X5_SIGNAL_PROVIDERS provider, // Provider State - bool state // Which state is going to set ... - ) - { - // - if (provider == X5NONE) - { - return; - } - - // - switch (provider) - { - // - case X5XSP: - mIsX5XSPSignalProviderEnable = state; - break; - - // - case XTD: - mIsXTDSignalProviderEnable = state; - break; - - // - case XTAM: - mIsXTAMSignalProviderEnable = state; - break; - - // - case XSI: - mIsXSISignalProviderEnable = state; - break; - - // - case XTSFI: - mIsXTSFISignalProviderEnable = state; - break; - - // - case XOBDLH: - mIsXOBDLHSignalProviderEnable = state; - break; - - // - case XCHMACC: - mIsXCHMACCSignalProviderEnable = state; - break; - - // - case XCHMAMN: - mIsXCHMAMNSignalProviderEnable = state; - break; - - // - case XCHMAMX: - mIsXCHMAMXSignalProviderEnable = state; - break; - } - } - - // - void SetSignalProviderStates( - ENUM_X5_SIGNAL_PROVIDERS &providers[], // Collection of Providers ... - bool state // Which state is going to set ... - ) - { - // - int providersCount = ArraySize(providers); - if (providersCount <= 0) - { - return; - } - - // - for (int i = 0; i < providersCount; i++) - { - SetSignalProviderState(providers[i], state); - } - } - - // - virtual string GetTag() - { - // - string result = NULL; - - // - result = - // - GetToken() + - "[" + - GetSymbol() + - "," + - ToString(GetPeriod()) + - "]" - // - ; - - // - return result; - } - - // - void GetMarketConditions( - X5MarketConditions &mConditions, // Market Conditions Result - int barIndex = 0 // Specified Bar Index - ) - { - // - mConditions.Clear(); - - // - if (barIndex < 0) - { - barIndex = 0; - } - - // - if (barIndex >= CountBars()) - { - barIndex = CountBars() + 2; - } - - // - int curr = barIndex + 1; - int prev = curr + 1; - - // - mConditions.symbol = GetSymbol(); - mConditions.period = GetPeriod(); - mConditions.time = iTime( - mConditions.symbol, - mConditions.period, - barIndex); - - // - GetBars( - mConditions.bars, - mConditions.symbol, - mConditions.period, - barIndex, - mNumberOfItems // - ); - - // - // XTM ... - tmHelper.CopyMain( - barIndex, - mNumberOfItems, - mConditions.tms); - - // - // XAMA ... - amaHelper.CopyMain( - barIndex, - mNumberOfItems, - mConditions.amas); - - // - // XFI ... - fiHelper.CopyMain( - barIndex, - mNumberOfItems, - mConditions.fis); - - // - // XOBD ... - obdHelper.CopyMain( - barIndex, - mNumberOfItems, - mConditions.obds); - - // - // XRSI ... - rsiHelper.CopyMain( - barIndex, - mNumberOfItems, - mConditions.rsis); - - // - // XLH ... - - // - // HH ... - lhHelper.CopyHH( - barIndex, - mNumberOfItems, - mConditions.lhHhs); - - // - // LL ... - lhHelper.CopyLL( - barIndex, - mNumberOfItems, - mConditions.lhLls); - - // - // Signal ... - lhHelper.CopySignal( - barIndex, - mNumberOfItems, - mConditions.lhSignals); - - // - // XTD ... - - // - // Bullish ... - tdHelper.CopyBullish( - barIndex, - mNumberOfItems, - mConditions.tdBullishs); - - // - // Bearish ... - tdHelper.CopyBearish( - barIndex, - mNumberOfItems, - mConditions.tdBearishs); - - // - // Signal ... - tdHelper.CopySignal( - barIndex, - mNumberOfItems, - mConditions.tdSignals); - - // - // XTS ... - - // - // Current ... - tsHelper.CopyCurrent( - barIndex, - mNumberOfItems, - mConditions.tsCurrents); - - // - // Nearest ... - tsHelper.CopyNearest( - barIndex, - mNumberOfItems, - mConditions.tsNearests); - - // - // Mediest ... - tsHelper.CopyMediest( - barIndex, - mNumberOfItems, - mConditions.tsMediests); - - // - // Farest ... - tsHelper.CopyFarest( - barIndex, - mNumberOfItems, - mConditions.tsFarests); - - // - // XCHMA ... - - // - // Short ... - - // - // Fast ... - chmaHelper.CopySCFast( - barIndex, - mNumberOfItems, - mConditions.chmaScFasts); - - // - // Slow ... - chmaHelper.CopySCSlow( - barIndex, - mNumberOfItems, - mConditions.chmaScSlows); - - // - // Medium ... - - // - // Fast ... - chmaHelper.CopyMCFast( - barIndex, - mNumberOfItems, - mConditions.chmaMcFasts); - - // - // Slow ... - chmaHelper.CopyMCSlow( - barIndex, - mNumberOfItems, - mConditions.chmaMcSlows); - - // - // Long ... - - // - // Fast ... - chmaHelper.CopyLCFast( - barIndex, - mNumberOfItems, - mConditions.chmaLcFasts); - - // - // Slow ... - chmaHelper.CopyLCSlow( - barIndex, - mNumberOfItems, - mConditions.chmaLcSlows); - - // - // Hot States ... - chmaHelper.CopyHotState( - barIndex, - mNumberOfItems, - mConditions.chmaHotStates); - - // - // XCHLH ... - - // - // Short ... - - // - // HH ... - chlhHelper.CopySCHH( - barIndex, - mNumberOfItems, - mConditions.chlhScHHs); - - // - // LL ... - chlhHelper.CopySCLL( - barIndex, - mNumberOfItems, - mConditions.chlhScLLs); - - // - // Medium ... - - // - // HH ... - chlhHelper.CopyMCHH( - barIndex, - mNumberOfItems, - mConditions.chlhMcHHs); - - // - // LL ... - chlhHelper.CopyMCLL( - barIndex, - mNumberOfItems, - mConditions.chlhMcLLs); - - // - // Long ... - - // - // HH ... - chlhHelper.CopyLCHH( - barIndex, - mNumberOfItems, - mConditions.chlhLcHHs); - - // - // LL ... - chlhHelper.CopyLCLL( - barIndex, - mNumberOfItems, - mConditions.chlhLcLLs); - - // - // Hot State ... - chlhHelper.CopyHotState( - barIndex, - mNumberOfItems, - mConditions.chlhHotStates); - - // - // Filling Bars ... - mCycle.GetBars( - mConditions.bars, - 0, - mNumberOfItems); - - // - CalculateConditions(mConditions); - } - - // - // Check Market For Signal ... - virtual bool HasSignal( - int barIndex, - XSignal &mSignal, // Hold's Signal if Exists ... - X5MarketConditions &mConditions // Hold's Market Conditions ... - ) - { - // - bool result = false; - - // - // Validate Enable Process ... - result = !CanIgnoreProcess(); - if (!result) - { - return result; - } - - // - mWaitsUntilNewBar = false; - - // - // Validate Enable Type of Signalling ... - result = mIsLongEnable || mIsShortEnable; - if (!result) - { - return result; - } - - // - // Now we Have to Pass the Conditions to Each Signal Provider - // for Retrieving Signals Based On them ... - - // - // Reading Market Conditions ... - GetMarketConditions(mConditions, barIndex); - - // - int signalPusher = 0; - bool hasLong = false; - bool hasShort = false; - string provider = ""; - - // - // Long ... - if (mIsLongEnable) - { - // - signalPusher = 0; - - // - hasLong = HasSpecificSignal( - barIndex, - POSITION_TYPE_BUY, - provider, - signalPusher, - mConditions // - ); - } - - // - // Short ... - if (mIsShortEnable) - { - // - signalPusher = 0; - - // - hasShort = HasSpecificSignal( - barIndex, - POSITION_TYPE_SELL, - provider, - signalPusher, - mConditions // - ); - } - - // - result = hasLong || hasShort; - if (!result) - { - return result; - } - - // - // Prepare Signal ... - - // - if (result) - { - // - // Here We Have to Prepare Signal ... - - // - // TODO: Make this Configurable ... - string symbol = GetSymbol(); - ENUM_TIMEFRAMES period = GetPeriod(); - double tpPoint = 30; - double volume = 0.01; - double tpPrice = PointToPrice( - tpPoint, - symbol // - ); - ENUM_POSITION_TYPE type = hasLong - ? POSITION_TYPE_BUY - : POSITION_TYPE_SELL; - ENUM_X_ORDER_MODES mode = X_ORDER_MODE_MARKET; - double entry = GetEntry( - symbol, - type // - ); - double tp = hasLong - ? entry + tpPrice - : entry - tpPrice; - double sl = 0; - ENUM_X_SIGNAL_MANAGING_ACTIONS action = X_SIGNAL_USE_NOTHING; - - // - result = mSignal.Prepare( - symbol, - provider, - period, - type, - mode, - entry, - volume, - action, - sl, - tp - // - ); - - // - if (result) - { - mWaitsUntilNewBar = true; - } - } - - // - return result; - } - - // - // Protected ... -protected: - // - X5ProviderInputs mInputs; - - // - // Private ... -private: - // - // Props ... - - // - // Prepare an Instance of Data Collector for MarketConditions ... - XSC5MarketConditionDataCollector mConditionsCollector; - - // - int mNumberOfItems; // Number of Buffer Ites Read in Conditions ... - - // - // Tools ... - - // - // Calculations ... - - // - // Calculate Conditions ... - void CalculateConditions(X5MarketConditions &mConditions) - { - // - CalculateTMConditions(mConditions); - CalculateAMAConditions(mConditions); - CalculateFIConditions(mConditions); - CalculateOBDConditions(mConditions); - CalculateRSIConditions(mConditions); - CalculateCHLHConditions(mConditions); - CalculateLHConditions(mConditions); - CalculateTDConditions(mConditions); - CalculateTSConditions(mConditions); - CalculateCHMAConditions(mConditions); - } - - // - // XTM .. - void CalculateTMConditions(X5MarketConditions &mConditions) - { - // - int mIndex = 0; - int mPrevIndex = mIndex + 1; - int mLength = 10; - int mFrom = mIndex + mLength; - - // - mConditions.isXTMPeak = IsIncreasing( - mFrom, - mIndex, - mConditions.tms); - - // - mConditions.isXTMVale = IsDecreasing( - mFrom, - mIndex, - mConditions.tms); - - // - mConditions.isXTMBullish = mConditions.bars[mIndex].low > mConditions.tms[mIndex]; - bool isXTMBullishPrev = mConditions.bars[mPrevIndex].low > mConditions.tms[mPrevIndex]; - - // - mConditions.isXTMBearish = mConditions.bars[mIndex].high < mConditions.tms[mIndex]; - bool isXTMBearishPrev = mConditions.bars[mPrevIndex].high < mConditions.tms[mPrevIndex]; - - // - mConditions.isXTMNeutural = !mConditions.isXTMBullish && !mConditions.isXTMBearish; - bool isXTMNeuturalPrev = !isXTMBullishPrev && !isXTMBearishPrev; - - // - mConditions.isXTMEndBullish = - // - !mConditions.isXTMBullish && - isXTMBullishPrev - // - ; - - // - mConditions.isXTMEndBearish = - // - !mConditions.isXTMBearish && - isXTMBearishPrev - // - ; - - // - mConditions.isXTMStartBullish = - // - mConditions.isXTMBullish && - !isXTMBullishPrev - // - ; - - // - mConditions.isXTMStartBearish = - // - mConditions.isXTMBearish && - !isXTMBearishPrev - // - ; - - // - mConditions.isXTMEndBullishByNeutural = - // - mConditions.isXTMNeutural && - isXTMBullishPrev - // - ; - - // - mConditions.isXTMEndBearishByNeutural = - // - mConditions.isXTMNeutural && - isXTMBearishPrev - // - ; - - // - mConditions.isXTMStartBullishAfterNeutural = - // - mConditions.isXTMBullish && - isXTMNeuturalPrev - // - ; - - // - mConditions.isXTMStartBearishAfterNeutural = - // - mConditions.isXTMBearish && - isXTMNeuturalPrev - // - ; - } - - // - // XAMA .. - void CalculateAMAConditions(X5MarketConditions &mConditions) - { - // - int mIndex = 0; - int mPrevIndex = mIndex + 1; - int mLength = 10; - int mFrom = mIndex + mLength; - - // - mConditions.isXAMAPeak = IsIncreasing( - mFrom, - mIndex, - mConditions.amas); - - // - mConditions.isXAMAVale = IsDecreasing( - mFrom, - mIndex, - mConditions.amas); - - // - mConditions.isXAMABullish = mConditions.bars[mIndex].low > mConditions.amas[mIndex]; - bool isXAMABullishPrev = mConditions.bars[mPrevIndex].low > mConditions.amas[mPrevIndex]; - - // - mConditions.isXAMABearish = mConditions.bars[mIndex].high < mConditions.amas[mIndex]; - bool isXAMABearishPrev = mConditions.bars[mPrevIndex].high < mConditions.amas[mPrevIndex]; - - // - mConditions.isXAMANeutural = !mConditions.isXAMABullish && !mConditions.isXAMABearish; - bool isXAMANeuturalPrev = !isXAMABullishPrev && !isXAMABearishPrev; - - // - mConditions.isXAMAEndBullish = - // - !mConditions.isXAMABullish && - isXAMABullishPrev - // - ; - - // - mConditions.isXAMAEndBearish = - // - !mConditions.isXAMABearish && - isXAMABearishPrev - // - ; - - // - mConditions.isXAMAStartBullish = - // - mConditions.isXAMABullish && - !isXAMABullishPrev - // - ; - - // - mConditions.isXAMAStartBearish = - // - mConditions.isXAMABearish && - !isXAMABearishPrev - // - ; - - // - mConditions.isXAMAEndBullishByNeutural = - // - mConditions.isXAMANeutural && - isXAMABullishPrev - // - ; - - // - mConditions.isXAMAEndBearishByNeutural = - // - mConditions.isXAMANeutural && - isXAMABearishPrev - // - ; - - // - mConditions.isXAMAStartBullishAfterNeutural = - // - mConditions.isXAMABullish && - isXAMANeuturalPrev - // - ; - - // - mConditions.isXAMAStartBearishAfterNeutural = - // - mConditions.isXAMABearish && - isXAMANeuturalPrev - // - ; - } - - // - // XFI ... - void CalculateFIConditions(X5MarketConditions &mConditions) - { - // - int mIndex = 0; - int mPrevIndex = mIndex + 1; - int mLength = 10; - int mFrom = mIndex + mLength; - - // - mConditions.isXFIPeak = IsIncreasing( - mFrom, - mIndex, - mConditions.fis); - - // - mConditions.isXFIVale = IsDecreasing( - mFrom, - mIndex, - mConditions.fis); - - // - mConditions.isXFIOverZero = mConditions.fis[mIndex] > 0; - - // - mConditions.isXFICrossedOverZero = - // - mConditions.isXFIOverZero && - mConditions.fis[mPrevIndex] <= 0 - // - ; - - // - mConditions.isXFIUnderZero = mConditions.fis[mIndex] < 0; - - // - mConditions.isXFICrossedUnderZero = - // - mConditions.isXFIUnderZero && - mConditions.fis[mPrevIndex] >= 0 - // - ; - } - - // - // XOBD ... - void CalculateOBDConditions(X5MarketConditions &mConditions) - { - // - int mIndex = 0; - int mPrevIndex = mIndex + 1; - int mLength = 10; - int mFrom = mIndex + mLength; - - // - mConditions.isXOBDSwingLow = mConditions.obds[mIndex] == X_SWING_LOW; - mConditions.isXOBDSwingHigh = mConditions.obds[mIndex] == X_SWING_HIGH; - } - - // - // XRSI ... - void CalculateRSIConditions(X5MarketConditions &mConditions) - { - // - int mIndex = 0; - int mPrevIndex = mIndex + 1; - int mLength = 10; - int mFrom = mIndex + mLength; - - // - double shortEntryValue = mInputs.rsiInputs.shortEntryValue; - double shortExitValue = mInputs.rsiInputs.shortExitValue; - double longEntryValue = mInputs.rsiInputs.longEntryValue; - double longExitValue = mInputs.rsiInputs.longExitValue; - - // - mConditions.isXRSIPeak = IsIncreasing( - mFrom, - mIndex, - mConditions.rsis); - - // - mConditions.isXRSIVale = IsDecreasing( - mFrom, - mIndex, - mConditions.rsis); - - // - mConditions.isXRSICrossedOverLongExit = - // - mConditions.rsis[mIndex] > longExitValue && - mConditions.rsis[mPrevIndex] <= longExitValue; - // - ; - - // - mConditions.isXRSICrossedOverLongEntry = - // - mConditions.rsis[mIndex] > longEntryValue && - mConditions.rsis[mPrevIndex] <= longEntryValue; - // - ; - - // - mConditions.isXRSICrossedUnderShortExit = - // - mConditions.rsis[mIndex] < shortExitValue && - mConditions.rsis[mPrevIndex] >= shortExitValue; - // - ; - - // - mConditions.isXRSICrossedUnderShortEntry = - // - mConditions.rsis[mIndex] < shortEntryValue && - mConditions.rsis[mPrevIndex] >= shortEntryValue; - // - ; - } - - // - // XCHLH ... - void CalculateCHLHConditions(X5MarketConditions &mConditions) - { - // - int mIndex = 0; - int mPrevIndex = mIndex + 1; - int mLength = 10; - int mFrom = mIndex + mLength; - - // - mConditions.isXCHLHSameHHs = - // - mConditions.chlhScHHs[mIndex] == mConditions.chlhMcHHs[mIndex] && - mConditions.chlhMcHHs[mIndex] == mConditions.chlhLcHHs[mIndex] - // - ; - - // - mConditions.isXCHLHSameLLs = - // - mConditions.chlhScLLs[mIndex] == mConditions.chlhMcLLs[mIndex] && - mConditions.chlhMcLLs[mIndex] == mConditions.chlhLcLLs[mIndex] - // - ; - - // - mConditions.isXCHLHSCMCHHSame = - // - mConditions.chlhScHHs[mIndex] == mConditions.chlhMcHHs[mIndex] - // - ; - - // - mConditions.isXCHLHSCMCLLSame = - // - mConditions.chlhScLLs[mIndex] == mConditions.chlhMcLLs[mIndex] - // - ; - - // - mConditions.isXCHLHSCLCHHSame = - // - mConditions.chlhScHHs[mIndex] == mConditions.chlhLcLLs[mIndex] - // - ; - - // - mConditions.isXCHLHSCLCLLSame = - // - mConditions.chlhScLLs[mIndex] == mConditions.chlhLcLLs[mIndex] - // - ; - - // - mConditions.isXCHLHMCLCHHSame = - // - mConditions.chlhMcHHs[mIndex] == mConditions.chlhLcHHs[mIndex] - // - ; - - // - mConditions.isXCHLHMCLCLLSame = - // - mConditions.chlhMcLLs[mIndex] == mConditions.chlhLcLLs[mIndex] - // - ; - - // // - // isXCHLHMCOnTopOfLC = - // // - // // - // ; - - // // - // isXCHLHMCInBottomOfLC = - // // - // // - // ; - } - - // - // XLH ... - void CalculateLHConditions(X5MarketConditions &mConditions) - { - // - int mIndex = 0; - int mPrevIndex = mIndex + 1; - int mLength = 10; - int mFrom = mIndex + mLength; - - // - mConditions.isXLHHHIncreased = IsIncreasing( - mFrom, - mIndex, - mConditions.lhHhs); - - // - mConditions.isXLHHHDecreased = IsDecreasing( - mFrom, - mIndex, - mConditions.lhHhs); - - // - mConditions.isXLHLLIncreased = IsIncreasing( - mFrom, - mIndex, - mConditions.lhLls); - - // - mConditions.isXLHLLDecreased = IsDecreasing( - mFrom, - mIndex, - mConditions.lhLls); - - // - mConditions.isXLHLowAttachedLL = mConditions.bars[mIndex].low == mConditions.lhLls[mIndex]; - - // - mConditions.isXLHHighAttachedHH = mConditions.bars[mIndex].high == mConditions.lhHhs[mIndex]; - ; - - // - mConditions.isXLHHHSameInLength = IsSame(mConditions.lhHhs); - - // - mConditions.isXLHLLSameInLength = IsSame(mConditions.lhLls); - - // - mConditions.isXLHPriceOverSignal = mConditions.bars[mIndex].low > mConditions.lhSignals[mIndex]; - - // - mConditions.isXLHPriceUnderSignal = mConditions.bars[mIndex].high < mConditions.lhSignals[mIndex]; - - // - mConditions.isXLHPriceInSignalRange = !mConditions.isXLHPriceOverSignal && !mConditions.isXLHPriceUnderSignal; - - // - mConditions.isXLHPriceCrossedOverSignal = - // - mConditions.isXLHPriceOverSignal && - !(mConditions.bars[mPrevIndex].low > mConditions.lhSignals[mPrevIndex]) - // - ; - - // - mConditions.isXLHPriceCrossedUnderSignal = - // - mConditions.isXLHPriceUnderSignal && - !(mConditions.bars[mIndex].high < mConditions.lhSignals[mIndex]) - // - ; - } - - // - // XTD ... - void CalculateTDConditions(X5MarketConditions &mConditions) - { - // - int mIndex = 0; - int mPrevIndex = mIndex + 1; - int mLength = 10; - int mFrom = mIndex + mLength; - - // - mConditions.isXTDSignalPeak = IsIncreasing( - mFrom, - mIndex, - mConditions.tdSignals); - - // - mConditions.isXTDSignalVale = IsDecreasing( - mFrom, - mIndex, - mConditions.tdSignals); - - // - mConditions.isXTDBullishPeak = IsIncreasing( - mFrom, - mIndex, - mConditions.tdBullishs); - - // - mConditions.isXTDBullishVale = IsDecreasing( - mFrom, - mIndex, - mConditions.tdBullishs); - - // - mConditions.isXTDBearishPeak = IsIncreasing( - mFrom, - mIndex, - mConditions.tdBearishs); - - // - mConditions.isXTDBearishVale = IsDecreasing( - mFrom, - mIndex, - mConditions.tdBearishs); - - // - mConditions.isXTDBullOverBear = mConditions.tdBullishs[mIndex] > mConditions.tdBearishs[mIndex]; - bool isXTDBullOverBearPrev = mConditions.tdBullishs[mPrevIndex] > mConditions.tdBearishs[mPrevIndex]; - - // - mConditions.isXTDBullUnderBear = mConditions.tdBullishs[mIndex] < mConditions.tdBearishs[mIndex]; - bool isXTDBullUnderBearPrev = mConditions.tdBullishs[mPrevIndex] < mConditions.tdBearishs[mPrevIndex]; - - // - mConditions.isXTDSignalOverBear = mConditions.tdSignals[mIndex] > mConditions.tdBearishs[mIndex]; - bool isXTDSignalOverBearPrev = mConditions.tdSignals[mPrevIndex] > mConditions.tdBearishs[mPrevIndex]; - - // - mConditions.isXTDSignalUnderBear = mConditions.tdSignals[mIndex] < mConditions.tdBearishs[mIndex]; - bool isXTDSignalUnderBearPrev = mConditions.tdSignals[mPrevIndex] < mConditions.tdBearishs[mPrevIndex]; - - // - mConditions.isXTDBullCrossedOverBear = - mConditions.isXTDBullOverBear && - !isXTDBullOverBearPrev; - - // - mConditions.isXTDBullCrossedUnderBear = - mConditions.isXTDBullUnderBear && - !isXTDBullUnderBearPrev; - - // - mConditions.isXTDSignalCrossedOverBear = - mConditions.isXTDSignalOverBear && - !isXTDSignalOverBearPrev; - - // - mConditions.isXTDSignalCrossedUnderBear = - mConditions.isXTDSignalUnderBear && - !isXTDSignalUnderBearPrev; - } - - // - // XTS ... - void CalculateTSConditions(X5MarketConditions &mConditions) - { - // - int mIndex = 0; - int mPrevIndex = mIndex + 1; - int mLength = 10; - int mFrom = mIndex + mLength; - - // - double current = mConditions.tsCurrents[mIndex]; - double currentPrev = mConditions.tsCurrents[mPrevIndex]; - - // - double nearest = mConditions.tsNearests[mIndex]; - double nearestPrev = mConditions.tsNearests[mPrevIndex]; - - // - double mediest = mConditions.tsMediests[mIndex]; - double mediestPrev = mConditions.tsMediests[mPrevIndex]; - - // - double farest = mConditions.tsFarests[mIndex]; - double farestPrev = mConditions.tsFarests[mPrevIndex]; - - // - double tsValues[] = {current, nearest, mediest, farest}; - double tsMax = GetMax(tsValues); - double tsMin = GetMin(tsValues); - - // - double tsPrevValues[] = {currentPrev, nearestPrev, mediestPrev, farestPrev}; - double tsPrevMax = GetMax(tsPrevValues); - double tsPrevMin = GetMin(tsPrevValues); - - // - mConditions.isXTSAllSame = - // - current == nearest && - nearest == mediest && - mediest == farest - // - ; - - // - mConditions.isXTSCurrentMin = current == tsMin; - mConditions.isXTSCurrentMax = current == tsMax; - - // - mConditions.isXTSCurrentOverFarest = current > farest; - bool isXTSCurrentOverFarestPrev = currentPrev > farestPrev; - - // - mConditions.isXTSCurrentOverNearest = current > nearest; - bool isXTSCurrentOverNearestPrev = currentPrev > nearestPrev; - - // - mConditions.isXTSCurrentOverMediest = current > mediest; - bool isXTSCurrentOverMediestPrev = currentPrev > mediestPrev; - - // - mConditions.isXTSCurrentUnderFarest = current < farest; - bool isXTSCurrentUnderFarestPrev = currentPrev < farestPrev; - - // - mConditions.isXTSCurrentUnderNearest = current < nearest; - bool isXTSCurrentUnderNearestPrev = currentPrev < nearestPrev; - - // - mConditions.isXTSCurrentUnderMediest = current < mediest; - bool isXTSCurrentUnderMediestPrev = currentPrev < mediestPrev; - - // - mConditions.isXTSCurrentCrossedOverFarest = - mConditions.isXTSCurrentOverFarest && - !isXTSCurrentOverFarestPrev; - - // - mConditions.isXTSCurrentCrossedOverNearest = - mConditions.isXTSCurrentOverNearest && - !isXTSCurrentOverNearestPrev; - - // - mConditions.isXTSCurrentCrossedOverMediest = - mConditions.isXTSCurrentOverMediest && - !isXTSCurrentOverMediestPrev; - - // - mConditions.isXTSCurrentCrossedUnderFarest = - mConditions.isXTSCurrentUnderFarest && - !isXTSCurrentUnderFarestPrev; - - // - mConditions.isXTSCurrentCrossedUnderNearest = - mConditions.isXTSCurrentUnderNearest && - !isXTSCurrentUnderNearestPrev; - - // - mConditions.isXTSCurrentCrossedUnderMediest = - mConditions.isXTSCurrentUnderMediest && - !isXTSCurrentUnderMediestPrev; - } - - // - // XCHMA ... - void CalculateCHMAConditions(X5MarketConditions &mConditions) - { - // - int mIndex = 0; - int mPrevIndex = mIndex + 1; - int mLength = 10; - int mFrom = mIndex + mLength; - - // - double scFast = mConditions.chmaScFasts[mIndex]; - double scSlow = mConditions.chmaScSlows[mIndex]; - double scFastPrev = mConditions.chmaScFasts[mPrevIndex]; - double scSlowPrev = mConditions.chmaScSlows[mPrevIndex]; - - // - double mcFast = mConditions.chmaMcFasts[mIndex]; - double mcSlow = mConditions.chmaMcSlows[mIndex]; - double mcFastPrev = mConditions.chmaMcFasts[mPrevIndex]; - double mcSlowPrev = mConditions.chmaMcSlows[mPrevIndex]; - - // - double lcFast = mConditions.chmaLcFasts[mIndex]; - double lcSlow = mConditions.chmaLcSlows[mIndex]; - double lcFastPrev = mConditions.chmaLcFasts[mPrevIndex]; - double lcSlowPrev = mConditions.chmaLcSlows[mPrevIndex]; - - // - double chmaValues[] = { - scFast, - scSlow, - mcFast, - mcSlow, - lcFast, - lcSlow}; - double chmaNonSCValues[] = { - mcFast, - mcSlow, - lcFast, - lcSlow}; - double chmaMin = GetMin(chmaValues); - double chmaMax = GetMax(chmaValues); - double chmaNonSCMin = GetMin(chmaNonSCValues); - double chmaNonSCMax = GetMax(chmaNonSCValues); - - // - double chmaValuesPrev[] = { - scFastPrev, - scSlowPrev, - mcFastPrev, - mcSlowPrev, - lcFastPrev, - lcSlowPrev}; - double chmaNonSCValuesPrev[] = { - mcFastPrev, - mcSlowPrev, - lcFastPrev, - lcSlowPrev}; - double chmaMinPrev = GetMin(chmaValuesPrev); - double chmaMaxPrev = GetMax(chmaValuesPrev); - double chmaNonSCMinPrev = GetMin(chmaNonSCValuesPrev); - double chmaNonSCMaxPrev = GetMax(chmaNonSCValuesPrev); - - // - mConditions.isXCHMASCOverMax = MathMin(scFast, scSlow) > chmaNonSCMax; - bool isXCHMASCOverMaxPrev = MathMin(scFastPrev, scSlowPrev) > chmaNonSCMaxPrev; - - // - mConditions.isXCHMASCOverMin = MathMin(scFast, scSlow) > chmaNonSCMin; - bool isXCHMASCOverMinPrev = MathMin(scFastPrev, scSlowPrev) > chmaNonSCMinPrev; - - // - mConditions.isXCHMASCUnderMax = MathMax(scFast, scSlow) < chmaNonSCMax; - bool isXCHMASCUnderMaxPrev = MathMax(scFastPrev, scSlowPrev) < chmaNonSCMaxPrev; - - // - mConditions.isXCHMASCUnderMin = MathMax(scFast, scSlow) < chmaNonSCMin; - bool isXCHMASCUnderMinPrev = MathMax(scFastPrev, scSlowPrev) < chmaNonSCMinPrev; - - // - mConditions.isXCHMASCCrossedOverMax = - mConditions.isXCHMASCOverMax && - !isXCHMASCOverMaxPrev; - - // - mConditions.isXCHMASCCrossedUnderMax = - mConditions.isXCHMASCUnderMax && - !isXCHMASCUnderMaxPrev; - - // - mConditions.isXCHMASCCrossedOverMin = - mConditions.isXCHMASCOverMin && - !isXCHMASCOverMinPrev; - - // - mConditions.isXCHMASCCrossedUnderMin = - mConditions.isXCHMASCUnderMin && - !isXCHMASCUnderMinPrev; - - // - // Short ... - - // - mConditions.isXCHMASCPeak = IsIncreasing( - mFrom, - mIndex, - mConditions.chmaScFasts); - - // - mConditions.isXCHMASCVale = IsDecreasing( - mFrom, - mIndex, - mConditions.chmaScFasts); - - // - mConditions.isXCHMASCTrendsUp = IsTrendingUp( - mConditions.chmaScFasts, - mConditions.chmaScSlows); - - // - mConditions.isXCHMASCTrendsDown = IsTrendingDown( - mConditions.chmaScFasts, - mConditions.chmaScSlows); - - // - mConditions.isXCHMASCFastOverSlow = scFast > scSlow; - bool isXCHMASCFastOverSlowPrev = scFastPrev > scSlowPrev; - - // - mConditions.isXCHMASCFastUnderSlow = scFast < scSlow; - bool isXCHMASCFastUnderSlowPrev = scFastPrev < scSlowPrev; - - // - mConditions.isXCHMASCFastCrossedOverSlow = - mConditions.isXCHMASCFastOverSlow && - !isXCHMASCFastOverSlowPrev; - - // - mConditions.isXCHMASCFastCrossedUnderSlow = - mConditions.isXCHMASCFastUnderSlow && - !isXCHMASCFastUnderSlowPrev; - - // - // Medium ... - - // - mConditions.isXCHMAMCPeak = IsIncreasing( - mFrom, - mIndex, - mConditions.chmaMcFasts); - - // - mConditions.isXCHMAMCVale = IsDecreasing( - mFrom, - mIndex, - mConditions.chmaMcFasts); - - // - mConditions.isXCHMAMCTrendsUp = IsTrendingUp( - mConditions.chmaMcFasts, - mConditions.chmaMcSlows); - - // - mConditions.isXCHMAMCTrendsDown = IsTrendingDown( - mConditions.chmaMcFasts, - mConditions.chmaMcSlows); - - // - mConditions.isXCHMAMCFastOverSlow = mcFast > mcSlow; - bool isXCHMAMCFastOverSlowPrev = mcFastPrev > mcSlowPrev; - - // - mConditions.isXCHMAMCFastUnderSlow = mcFast < mcSlow; - bool isXCHMAMCFastUnderSlowPrev = mcFastPrev < mcSlowPrev; - - // - mConditions.isXCHMAMCFastCrossedOverSlow = - mConditions.isXCHMAMCFastOverSlow && - !isXCHMAMCFastOverSlowPrev; - - // - mConditions.isXCHMAMCFastCrossedUnderSlow = - mConditions.isXCHMAMCFastUnderSlow && - !isXCHMAMCFastUnderSlowPrev; - - // - // Long ... - - // - mConditions.isXCHMALCPeak = IsIncreasing( - mFrom, - mIndex, - mConditions.chmaLcFasts); - - // - mConditions.isXCHMALCVale = IsDecreasing( - mFrom, - mIndex, - mConditions.chmaLcFasts); - - // - mConditions.isXCHMALCTrendsUp = IsTrendingUp( - mConditions.chmaLcFasts, - mConditions.chmaLcSlows); - - // - mConditions.isXCHMALCTrendsDown = IsTrendingDown( - mConditions.chmaMcFasts, - mConditions.chmaMcSlows); - - // - mConditions.isXCHMALCFastOverSlow = lcFast > lcSlow; - bool isXCHMALCFastOverSlowPrev = lcFastPrev > lcSlowPrev; - - // - mConditions.isXCHMALCFastUnderSlow = lcFast < lcSlow; - bool isXCHMALCFastUnderSlowPrev = lcFastPrev < lcSlowPrev; - - // - mConditions.isXCHMALCFastCrossedOverSlow = - mConditions.isXCHMALCFastOverSlow && - !isXCHMALCFastOverSlowPrev; - - // - mConditions.isXCHMALCFastCrossedUnderSlow = - mConditions.isXCHMALCFastUnderSlow && - !isXCHMALCFastUnderSlowPrev; - } - - // - // Signallers ... - - // - bool mIsLongEnable; - bool mIsShortEnable; - - // - bool mIsX5XSPSignalProviderEnable; - bool mIsXTDSignalProviderEnable; - bool mIsXTAMSignalProviderEnable; - bool mIsXSISignalProviderEnable; - bool mIsXTSFISignalProviderEnable; - bool mIsXOBDLHSignalProviderEnable; - bool mIsXCHMACCSignalProviderEnable; - bool mIsXCHMAMNSignalProviderEnable; - bool mIsXCHMAMXSignalProviderEnable; - - // - // Check Market Conditions is Ready for Long Signals or not ... - bool IsReadyForLong( - X5MarketConditions &mConditions, // Market Conditions ... - bool checkXCHMAMin = true, // Force Check XCHMA Min State - bool checkXCHMAMax = true, // Force Check XCHMA Max State - bool checkXCHMACycles = true, // Force Check XCHMA Cycles State - bool checkXCHMAPeaks = true, // Force Check XCHMA Peaks State - bool checkXCHMATrendPowers = true, // Force Check XCHMA Trend Powers - bool checkXOBD = true, // Force Check XOBD State - bool checkXTS = true // Force Check XTS State - ) - { - // - bool result = true; - - // - if (checkXCHMAMin) - { - // - result = - // - // XCHMA MIN ... - !( - // - (mConditions.isXCHMASCOverMin || - mConditions.isXCHMASCCrossedOverMin) && - (mConditions.isXCHMASCUnderMin || - mConditions.isXCHMASCCrossedUnderMin) - // - ); - } - - // - if (checkXCHMAMax && result) - { - // - result = - // - // XCHMA MAX ... - !( - // - (mConditions.isXCHMASCOverMax || - mConditions.isXCHMASCCrossedOverMax) && - (mConditions.isXCHMASCUnderMax || - mConditions.isXCHMASCCrossedUnderMax) - // - ) - // - ; - } - - // - if (checkXCHMACycles && result) - { - // - result = - // - // Check XCHMA Trend Bullish ... - ( - // - // All Cycles Bullish ... - ( - // - // SC ... - (mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) - // - && - // - // MC ... - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) - // - && - // - // LC ... - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) - // - ) - // - || - // - // Two Cycle Fully Bullish ... - ( - // - // SC and MC ... - ( - // - // SC ... - (mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) - // - && - // - // MC ... - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) - // - ) - // - || - // - // SC and LC ... - ( - // - // SC ... - (mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) - // - && - // - // LC ... - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) - // - ) - // - || - // - // MC and LC ... - ( - // - // MC ... - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) - // - && - // - // LC ... - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) - // - ) - // - ) - // - ) - // - ; - } - - // - if (checkXCHMAPeaks && result) - { - // - result = - // - // XCHMA Check Peaks ... - !( - // - // All Cycles Peak ... - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) - // - || - // - ( - // - // SC MC ... - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak) - // - || - // - // SC LC ... - (mConditions.isXCHMASCPeak && - mConditions.isXCHMALCPeak) - // - || - // - // MC LC ... - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) - // - ) - // - ) - // - ; - } - - // - if (checkXCHMATrendPowers && result) - { - // - result = - // - // XCHMA Check Trends Power ... - !( - // - // All Trends Down ... - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - || - // - // Twisted pairs ... - ( - // - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown) - // - || - // - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - || - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - ; - } - - // - if (checkXOBD && result) - { - // - result = - // - // XOBD Check Swings ... - !mConditions.isXOBDSwingLow - // - ; - } - - // - if (checkXTS && result) - { - result = - // - // XTS Check ... - !( - // - mConditions.isXTSCurrentMin && - // - ( - // - // All Under ... - ( - (mConditions.isXTSCurrentUnderNearest || - mConditions.isXTSCurrentCrossedUnderNearest) && - (mConditions.isXTSCurrentUnderMediest || - mConditions.isXTSCurrentCrossedUnderMediest) && - (mConditions.isXTSCurrentUnderFarest || - mConditions.isXTSCurrentCrossedUnderFarest)) - // - || - // - // Pairs ... - ( - // - ((mConditions.isXTSCurrentUnderNearest || - mConditions.isXTSCurrentCrossedUnderNearest) && - (mConditions.isXTSCurrentUnderMediest || - mConditions.isXTSCurrentCrossedUnderMediest)) - // - || - // - ((mConditions.isXTSCurrentUnderNearest || - mConditions.isXTSCurrentCrossedUnderNearest) && - (mConditions.isXTSCurrentUnderFarest || - mConditions.isXTSCurrentCrossedUnderFarest)) - // - || - // - ((mConditions.isXTSCurrentUnderMediest || - mConditions.isXTSCurrentCrossedUnderMediest) && - (mConditions.isXTSCurrentUnderFarest || - mConditions.isXTSCurrentCrossedUnderFarest)) - // - ) - // - ) - // - ) - // - ; - } - - // - return result; - } - - // - // Check Market Conditions is Ready for Short Signals or not ... - bool IsReadyForShort( - X5MarketConditions &mConditions, // Market Conditions ... - bool checkXCHMAMin = true, // Force Check XCHMA Min State - bool checkXCHMAMax = true, // Force Check XCHMA Max State - bool checkXCHMACycles = true, // Force Check XCHMA Cycles State - bool checkXCHMAVales = true, // Force Check XCHMA Vales State - bool checkXCHMATrendPowers = true, // Force Check XCHMA Trend Powers - bool checkXOBD = true, // Force Check XOBD State - bool checkXTS = true // Force Check XTS State - ) - { - // - bool result = true; - - // - if (checkXCHMAMin) - { - // - result = - // - // XCHMA MIN ... - !( - // - (mConditions.isXCHMASCOverMin || - mConditions.isXCHMASCCrossedOverMin) && - (mConditions.isXCHMASCUnderMin || - mConditions.isXCHMASCCrossedUnderMin) - // - ); - } - - // - if (checkXCHMAMax && result) - { - // - result = - // - // XCHMA MAX ... - !( - // - (mConditions.isXCHMASCOverMax || - mConditions.isXCHMASCCrossedOverMax) && - (mConditions.isXCHMASCUnderMax || - mConditions.isXCHMASCCrossedUnderMax) - // - ) - // - ; - } - - // - if (checkXCHMACycles && result) - { - // - result = - // - // Check XCHMA Trend Bullish ... - ( - // - // All Cycles Bullish ... - ( - // - // SC ... - (mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) - // - && - // - // MC ... - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) - // - && - // - // LC ... - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) - // - ) - // - || - // - // Two Cycle Fully Bullish ... - ( - // - // SC and MC ... - ( - // - // SC ... - (mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedOverSlow) - // - && - // - // MC ... - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) - // - ) - // - || - // - // SC and LC ... - ( - // - // SC ... - (mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) - // - && - // - // LC ... - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) - // - ) - // - || - // - // MC and LC ... - ( - // - // MC ... - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) - // - && - // - // LC ... - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedOverSlow) - // - ) - // - ) - // - ) - // - ; - } - - // - if (checkXCHMAVales && result) - { - // - result = - // - // XCHMA Check Vales ... - !( - // - // All Cycles Vale ... - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) - // - || - // - ( - // - // SC MC ... - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale) - // - || - // - // SC LC ... - (mConditions.isXCHMASCVale && - mConditions.isXCHMALCVale) - // - || - // - // MC LC ... - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) - // - ) - // - ) - // - ; - } - - // - if (checkXCHMATrendPowers && result) - { - // - result = - // - // XCHMA Check Trends Power ... - !( - // - // All Trends Down ... - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - || - // - // Twisted pairs ... - ( - // - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown) - // - || - // - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - || - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - ; - } - - // - if (checkXOBD && result) - { - // - result = - // - // XOBD Check Swings ... - !mConditions.isXOBDSwingHigh - // - ; - } - - // - if (checkXTS && result) - { - // - result = - // - // XTS Check ... - !( - // - mConditions.isXTSCurrentMax && - // - ( - // - // All Over ... - ( - (mConditions.isXTSCurrentOverNearest || - mConditions.isXTSCurrentCrossedOverNearest) && - (mConditions.isXTSCurrentOverMediest || - mConditions.isXTSCurrentCrossedOverMediest) && - (mConditions.isXTSCurrentOverFarest || - mConditions.isXTSCurrentCrossedOverFarest)) - // - || - // - // Pairs ... - ( - // - ((mConditions.isXTSCurrentOverNearest || - mConditions.isXTSCurrentCrossedOverNearest) && - (mConditions.isXTSCurrentOverMediest || - mConditions.isXTSCurrentCrossedOverMediest)) - // - || - // - ((mConditions.isXTSCurrentOverNearest || - mConditions.isXTSCurrentCrossedOverNearest) && - (mConditions.isXTSCurrentOverFarest || - mConditions.isXTSCurrentCrossedOverFarest)) - // - || - // - ((mConditions.isXTSCurrentOverMediest || - mConditions.isXTSCurrentCrossedOverMediest) && - (mConditions.isXTSCurrentOverFarest || - mConditions.isXTSCurrentCrossedOverFarest)) - // - ) - // - ) - // - ) - // - ; - } - - // - return result; - } - - // - // X5XSP ... - - // - // Common Conditions ... - bool X5XSPHasLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool X5XSPHasSpecifiedLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = X5XSPHasLongSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - result = - // - false - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - result = - // - false - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - result = - // - false - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - result = - // - false - // - ; - } - - // - return result; - } - - // - // X5XSP ... - - // - // Common Conditions ... - bool X5XSPHasShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool X5XSPHasSpecifiedShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = X5XSPHasShortSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - result = - // - false - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - result = - // - false - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - result = - // - false - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - result = - // - false - // - ; - } - - // - return result; - } - - // - // XTD ... - - // - // Common Conditions ... - bool XTDHasLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - mConditions.isXTDSignalCrossedOverBear - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForLong(mConditions) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XTDHasSpecifiedLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XTDHasLongSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXTDSignalCrossedOverBear && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) - // - || - // - ((mConditions.isXTSCurrentUnderNearest || - mConditions.isXTSCurrentCrossedUnderNearest) && - (mConditions.isXTSCurrentUnderMediest || - mConditions.isXTSCurrentCrossedUnderMediest) && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCLLSame) - // - || - // - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCCrossedOverMin && - mConditions.isXTDSignalCrossedOverBear && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) - // - || - // - ( - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTSCurrentMax) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentUnderNearest) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXFICrossedOverZero && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ( - (mConditions.isXCHMAMCVale && - mConditions.isXTDBearishVale) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame) - // - || - // - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) - // - || - // - (mConditions.isXLHLLIncreased && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - mConditions.isXTSCurrentUnderFarest && - (mConditions.isXTSCurrentUnderNearest || - mConditions.isXTSCurrentCrossedUnderNearest)) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMAMCTrendsDown) - // - ) - // - ) - // - || - // - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ( - (mConditions.isXCHMAMCVale && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) && - ( - // - ( - // - mConditions.isXAMANeutural - // - || - // - (mConditions.isXLHLLDecreased && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - || - // - // - ((mConditions.isXTSCurrentMax && - mConditions.isXLHHHDecreased) && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXCHLHMCLCLLSame && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTDSignalCrossedOverBear && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) - // - ) - // - ) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBullish && - mConditions.isXAMANeutural && - mConditions.isXAMAEndBullish && - mConditions.isXTDSignalCrossedOverBear && - (mConditions.isXTSCurrentUnderNearest || - mConditions.isXTSCurrentCrossedUnderNearest) && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXLHHHDecreased && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTDSignalCrossedOverBear && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) - // - ) - // - ) - // - || - // - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMANeutural && - mConditions.isXAMAEndBearish && - mConditions.isXTDBearishVale && - mConditions.isXTMStartBullish && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - || - // - // 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 ... - // - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMAMCVale && - // - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBullish) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXCHMALCVale && - mConditions.isXTMStartBullish && - mConditions.isXCHLHMCLCLLSame) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXTDBearishVale && - mConditions.isXCHLHMCLCHHSame) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXLHHHDecreased) - // - || - // - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) - // - ) - // - ) - // - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - ) - // - ) - // - || - // - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMAMCVale && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCLLSame) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXLHHHDecreased && - mConditions.isXFICrossedOverZero) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXAMAStartBearish && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXTSCurrentUnderFarest && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXAMAVale && - mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale && - mConditions.isXLHLLIncreased) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXFICrossedOverZero && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - || - // - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXTSCurrentMax && - mConditions.isXTMStartBullish && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check Conditions if Price is Over Signal ... - ( - // - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // Next Step is to Check LL and HH Same Style ... - // - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXLHHHIncreased && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDSignalCrossedOverBear && - (mConditions.isXCHMASCTrendsUp && - (mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow))) - // - || - // - (mConditions.isXTDSignalCrossedOverBear && - (mConditions.isXCHMALCVale && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow))) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentUnderNearest) - // - || - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentUnderNearest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - ( - // - mConditions.isXCHMASCCrossedOverMax - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - ( - // - (mConditions.isXTSCurrentUnderFarest || - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale && - mConditions.isXTDSignalCrossedOverBear) - // - ) && - (mConditions.isXCHMALCVale && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) && - ( - // - mConditions.isXRSICrossedOverLongExit - // - || - // - (mConditions.isXTSAllSame && - mConditions.isXAMAStartBullish && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXAMAStartBullish) - // - || - // - ((mConditions.isXTSCurrentUnderNearest || - mConditions.isXTSCurrentCrossedUnderNearest) && - (mConditions.isXTSCurrentUnderMediest || - mConditions.isXTSCurrentCrossedUnderMediest)) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXTSCurrentMax || - mConditions.isXTSCurrentUnderFarest) && - mConditions.isXTDBearishVale && - mConditions.isXLHLLDecreased && - mConditions.isXLHPriceCrossedOverSignal && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) - // - || - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXLHHighAttachedHH) - // - || - // - (mConditions.isXCHLHMCLCLLSame && - ( - // - (mConditions.isXCHMASCCrossedOverMin && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) - // - || - // - (mConditions.isXCHMASCCrossedOverMax && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) - // - ) - // - ) - // - || - // - (((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) || - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) && - // - ( - // - ((mConditions.isXTSCurrentUnderNearest || - mConditions.isXTSCurrentCrossedUnderNearest) && - (mConditions.isXTSCurrentUnderMediest || - mConditions.isXTSCurrentCrossedUnderMediest)) - // - ) - // - ) - // - ) - // - ) - // - || - // - (( - // - (mConditions.isXFICrossedOverZero && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) && - (mConditions.isXCHMALCVale && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow))) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXFIOverZero && - mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - || - // - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXCHLHMCLCHHSame && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) - // - || - // - (mConditions.isXTMEndBullish && - mConditions.isXTDBearishVale && - mConditions.isXFICrossedOverZero && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) - // - || - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMALCVale && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXFICrossedOverZero && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - || - // - (mConditions.isXAMAEndBullish && - mConditions.isXCHLHSCMCLLSame && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXCHMALCVale && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) - // - ) - // - ) - // - || - // - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - ) - // - ) - // - || - // - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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.isXTSCurrentUnderFarest && - ( - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalCrossedOverBear && - ( - // - (mConditions.isXTSCurrentCrossedUnderNearest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXTSAllSame && - mConditions.isXCHMAMCVale && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXTDBearishVale) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXRSICrossedOverLongExit && - ( - // - (mConditions.isXTSCurrentCrossedUnderNearest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXAMAStartBullish && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalCrossedOverBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTDBearishVale) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXTMStartBullish && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBearishVale && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCHHSame) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXAMAStartBullish && - mConditions.isXCHMASCFastCrossedOverSlow) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXTSCurrentCrossedUnderNearest && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXTMStartBullish && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTDBearishVale && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBullish && - mConditions.isXTMNeutural && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTDBearishVale) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // XTD Long ... - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTDSignalCrossedOverBear && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXTDBearishVale) - // - || - // - (mConditions.isXLHHHDecreased && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMNeutural || - mConditions.isXTMEndBullish) && - ( - // - (mConditions.isXTDSignalCrossedOverBear && - mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCOverMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCTrendsDown || - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXTSCurrentCrossedUnderNearest && - ( - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXCHLHSameHHs && - ( - // - ( - // - mConditions.isXLHHighAttachedHH - // - || - // - (mConditions.isXLHLLSameInLength && - mConditions.isXRSICrossedOverLongExit) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalCrossedOverBear && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXLHHighAttachedHH) && - ( - // - mConditions.isXCHLHSameHHs - // - || - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - false) - // - ) - // - || - // - // XTD 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 ... - // - // XTD Long ... - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - false) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - // XTD Long ... - // Resolve Guard Attacks ... - || - // - ( - // - // XTD Long ... - // isXTSCurrentUnderNearest - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXTSCurrentCrossedUnderNearest && - ( - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - mConditions.isXTSCurrentCrossedUnderFarest - // - || - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHMAMCFastUnderSlow) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceInSignalRange) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXLHHHSameInLength && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTDBearishVale) - // - || - // - (mConditions.isXLHPriceOverSignal && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXAMAStartBullish) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCOverMax && - mConditions.isXLHPriceOverSignal && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMAMCVale && - mConditions.isXTDBearishVale && - mConditions.isXCHLHMCLCLLSame) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - mConditions.isXLHPriceUnderSignal - // - || - // - (mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceUnderSignal && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - mConditions.isXLHPriceInSignalRange - // - || - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceOverSignal && - ( - // - ((mConditions.isXCHMASCOverMax && - mConditions.isXLHLLSameInLength) && - ( - // - mConditions.isXCHLHSCMCHHSame - // - || - // - mConditions.isXLHHHSameInLength - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXCHMALCVale && - ( - // - mConditions.isXCHLHMCLCHHSame - // - || - // - mConditions.isXLHHHSameInLength - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXLHHHIncreased && - mConditions.isXCHLHSCMCHHSame) - // - || - // - (mConditions.isXCHMASCOverMax && - ( - // - (mConditions.isXCHLHSCMCHHSame && - ( - // - mConditions.isXLHLLIncreased - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXLHLLSameInLength && - mConditions.isXCHMASCCrossedOverMax) - // - ) - // - ) - // - || - // - (mConditions.isXCHLHSameHHs && - ( - // - mConditions.isXLHLLSameInLength - // - || - // - (mConditions.isXTMNeutural || - mConditions.isXTMEndBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXCHLHSCMCHHSame && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXLHLLDecreased) - // - || - // - (mConditions.isXCHMASCOverMax && - mConditions.isXLHHighAttachedHH && - mConditions.isXCHMASCCrossedOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHHHSameInLength && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) || - (mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish)) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXLHHHSameInLength) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXLHLLSameInLength) - // - || - // - (mConditions.isXLHLLIncreased && - mConditions.isXLHPriceInSignalRange) - // - ) - // - ) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - mConditions.isXCHMASCCrossedOverMin - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXCHMASCCrossedOverMin && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMASCOverMax && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMAMCPeak) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXLHLLIncreased && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - mConditions.isXCHLHMCLCHHSame - // - || - // - (mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceOverSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMASCOverMax && - mConditions.isXLHPriceOverSignal && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXCHMASCFastCrossedOverSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXCHLHSCMCHHSame && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCOverMax) - // - || - // - ((mConditions.isXTDBearishVale && - mConditions.isXCHMASCCrossedOverMin) && - ( - // - (mConditions.isXTMNeutural && - ( - // - mConditions.isXAMANeutural - // - || - // - mConditions.isXAMAStartBullish - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXLHPriceCrossedUnderSignal && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale && - mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceInSignalRange && - ( - // - (mConditions.isXTDBearishVale && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - mConditions.isXTSCurrentCrossedOverMediest - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceOverSignal && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - ((mConditions.isXCHMASCOverMax && - mConditions.isXTDBearishVale) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - || - // - (mConditions.isXAMAStartBullish && - mConditions.isXLHPriceUnderSignal) - // - ) - // - ) - // - || - // - (mConditions.isXTDBearishVale && - ( - // - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXAMAStartBullish && - mConditions.isXLHLLSameInLength) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHLLSameInLength) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBearishVale && - mConditions.isXCHMALCFastUnderSlow && - mConditions.isXTSCurrentCrossedUnderNearest) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceOverSignal && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceInSignalRange && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - ((mConditions.isXTDBearishVale && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // isXTSCurrentUnderMediest - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - mConditions.isXCHLHMCLCHHSame - // - || - // - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceOverSignal) && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame) - // - || - // - (mConditions.isXLHHHSameInLength && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXAMABearish && - mConditions.isXTMNeutural && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXLHPriceInSignalRange) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXTDBearishVale && - ( - // - (mConditions.isXLHPriceUnderSignal && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - (mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHPriceOverSignal && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - || - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - || - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceInSignalRange && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceUnderSignal && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCCrossedOverMax) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceInSignalRange && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale && - mConditions.isXLHLLIncreased) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - ((mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceUnderSignal && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCCrossedOverMax) - // - ) - // - ) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish) - // - ) - // - ) - // - || - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXAMAEndBullish && - mConditions.isXLHHHDecreased && - mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceUnderSignal && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // isXTSCurrentUnderFarest - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXLHPriceUnderSignal && - ( - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXLHHHSameInLength && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXLHLLDecreased) - // - || - // - (mConditions.isXLHHHSameInLength && - ( - // - (mConditions.isXAMAVale && - mConditions.isXAMABearish && - mConditions.isXTMStartBullish) - // - || - // - (mConditions.isXTDBearishVale && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - mConditions.isXAMABearish - // - || - // - mConditions.isXLHLLSameInLength - // - || - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXLHHHSameInLength && - mConditions.isXLHPriceUnderSignal) - // - ) - // - ) - // - || - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXTDBearishVale) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCPeak && - mConditions.isXAMAStartBullish && - mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown) && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceUnderSignal && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXLHHHSameInLength && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale && - mConditions.isXCHLHMCLCHHSame) - // - || - // - (mConditions.isXLHHHSameInLength && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural) && - ( - // - mConditions.isXTSCurrentCrossedOverNearest - // - || - // - (mConditions.isXAMAVale && - mConditions.isXLHLLIncreased && - mConditions.isXTMStartBullish && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXAMAStartBullish && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXLHPriceInSignalRange && - ( - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXTSCurrentCrossedUnderFarest && - ( - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHSCMCLLSame) && - ( - // - (mConditions.isXTMNeutural && - ( - // - mConditions.isXAMANeutural - // - || - // - mConditions.isXTMEndBullish - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - || - // - (mConditions.isXLHHHSameInLength && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXCHMALCVale && - ( - // - mConditions.isXTDBearishVale - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - mConditions.isXCHMASCOverMax - // - || - // - (mConditions.isXTDBearishVale && - ( - // - mConditions.isXAMANeutural - // - || - // - mConditions.isXTMStartBullish - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - ((mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax && - mConditions.isXCHMALCTrendsDown) && - (!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow)) - // - || - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXTMNeutural && - mConditions.isXLHLLIncreased) && - ( - // - mConditions.isXCHMALCVale - // - || - // - (mConditions.isXTMEndBullish && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMALCPeak) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXAMAStartBullish && - mConditions.isXLHPriceInSignalRange) - // - || - // - (mConditions.isXLHPriceOverSignal && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHLLDecreased && - mConditions.isXTMStartBullish && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXAMAStartBullish && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // isXCHMAMCFastUnderSlow - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXLHPriceInSignalRange && - ( - // - (mConditions.isXLHLLSameInLength && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXAMANeutural && - mConditions.isXCHMASCUnderMin) - // - || - // - mConditions.isXTSCurrentCrossedOverNearest - // - ) - // - ) - // - || - // - (mConditions.isXLHHHSameInLength && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMax) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHHHSameInLength && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXAMAStartBullish) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceUnderSignal && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXCHMASCUnderMin) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentCrossedOverNearest) && - ( - // - (mConditions.isXLHLLDecreased && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXAMABearish && - mConditions.isXTMStartBullish && - mConditions.isXCHLHSCMCLLSame) - // - || - // - (mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCCrossedOverMin && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHHHSameInLength && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXTDBearishVale && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceOverSignal && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCLLSame) - // - || - // - ((mConditions.isXTSAllSame && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak) && - ( - // - (mConditions.isXTSCurrentMax && - ( - // - mConditions.isXLHHHDecreased - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXLHLLDecreased) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXLHHHSameInLength && - mConditions.isXLHPriceUnderSignal) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXTDBearishVale && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXAMABearish && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXTMStartBullish) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTSCurrentMax && - ( - // - (mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceUnderSignal) - // - || - // - (mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceInSignalRange && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXCHMASCUnderMin && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHPriceOverSignal && - mConditions.isXCHMASCCrossedOverMin && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax) && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHPriceOverSignal) && - ( - // - mConditions.isXTMStartBullish - // - || - // - ((mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXLHLLSameInLength && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // isXCHMALCFastUnderSlow - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCCrossedOverMax) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax) - // - || - // - ((mConditions.isXOBDSwingHigh && - mConditions.isXTSCurrentMax) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMax && - ( - // - (mConditions.isXLHPriceCrossedOverSignal && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCCrossedOverMax) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceInSignalRange && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentMax && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXLHHighAttachedHH) - // - || - // - (mConditions.isXTSAllSame && - mConditions.isXAMAStartBullish && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMASCOverMax && - ( - // - (mConditions.isXTSAllSame && - mConditions.isXCHMASCCrossedOverMax) - // - || - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalCrossedOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCCrossedOverMin && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax) && - ( - // - mConditions.isXTSCurrentCrossedOverNearest - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMAStartBullish) - // - || - // - (mConditions.isXTMStartBullish && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceInSignalRange && - ( - // - (mConditions.isXTSCurrentMax && - ( - // - (mConditions.isXCHLHSCMCHHSame && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHHHSameInLength && - ( - // - (mConditions.isXTSAllSame && - mConditions.isXCHMALCVale && - mConditions.isXLHPriceOverSignal && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - (mConditions.isXLHPriceInSignalRange && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceOverSignal && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXLHPriceOverSignal && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - mConditions.isXTDBearishVale - // - || - // - (mConditions.isXLHHHSameInLength && - ( - // - mConditions.isXLHLLSameInLength - // - || - // - (mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXLHHHSameInLength && - ( - // - mConditions.isXCHLHMCLCHHSame - // - || - // - mConditions.isXFICrossedOverZero - // - || - // - (mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax) - // - ) - // - ) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXCHMASCOverMin && - mConditions.isXTDBullOverBear && - mConditions.isXCHMASCUnderMax) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHLLSameInLength) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - mConditions.isXTSCurrentCrossedOverNearest - // - || - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - || - // - (((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) || - (mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish)) && - ( - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHSCMCLLSame) && - ( - // - (mConditions.isXTSCurrentMax && - ( - // - mConditions.isXTDBearishVale - // - || - // - (mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceInSignalRange) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXLHPriceOverSignal && - mConditions.isXLHLLSameInLength) && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXLHHHSameInLength && - ( - // - mConditions.isXCHLHSCMCHHSame - // - || - // - (mConditions.isXCHMASCOverMax && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHLHMCLCHHSame) - // - || - // - (mConditions.isXTSAllSame && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCCrossedOverMax) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXFIOverZero && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - || - // - ((mConditions.isXCHMAMCPeak || - mConditions.isXTDBearishVale) && - ( - // - (!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCOverMax && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHLHSameHHs) - // - || - // - (mConditions.isXCHLHSCMCHHSame && - ( - // - mConditions.isXLHHighAttachedHH - // - || - // - mConditions.isXTSCurrentCrossedOverMediest - // - ) - // - ) - // - ) - // - ) - // - || - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHLHMCLCLLSame) && - ( - // - mConditions.isXCHLHSCMCHHSame - // - || - // - mConditions.isXLHHHSameInLength - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceOverSignal && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCHHSame) && - ( - // - (mConditions.isXLHLLIncreased && - mConditions.isXLHHighAttachedHH) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceUnderSignal && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // isXCHMASCTrendsDown - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXTSCurrentMax && - ( - // - (mConditions.isXLHPriceInSignalRange && - ( - // - (mConditions.isXLHLLDecreased && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXTMStartBullish && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // isXCHMAMCTrendsDown - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXAMAStartBullish && - ( - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXLHPriceUnderSignal) - // - || - // - (mConditions.isXLHPriceInSignalRange && - ( - // - (mConditions.isXLHHHSameInLength && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXLHLLSameInLength) - // - || - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCCrossedOverMax) - // - || - // - (mConditions.isXCHMASCOverMin && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCUnderMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBearishVale && - ( - // - (mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceInSignalRange) - // - || - // - (mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBearishVale && - mConditions.isXLHPriceOverSignal) && - ( - // - (mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) - // - || - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXCHMASCCrossedOverMax) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBearishVale && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXTSAllSame && - mConditions.isXTMBearish && - mConditions.isXAMANeutural) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceUnderSignal && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceUnderSignal && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentCrossedOverFarest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTDBearishVale && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXAMANeutural && - ( - // - mConditions.isXTMNeutural - // - || - // - mConditions.isXCHLHMCLCHHSame - // - || - // - (mConditions.isXLHPriceUnderSignal && - ( - // - (mConditions.isXLHHHSameInLength && - ( - // - (mConditions.isXTMBullish && - mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - mConditions.isXAMAEndBearish - // - || - // - (mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceInSignalRange && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXLHLLDecreased && - mConditions.isXTMStartBullish && - mConditions.isXCHLHMCLCHHSame) && - ( - // - mConditions.isXAMANeutural - // - || - // - (mConditions.isXAMAStartBullish && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXTDBearishVale && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceUnderSignal && - ( - // - (mConditions.isXCHLHMCLCHHSame && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale && - mConditions.isXCHMASCFastCrossedOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXLHHHDecreased && - mConditions.isXAMAStartBullish && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // isXCHMALCTrendsDown - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - mConditions.isXCHMASCOverMax - // - || - // - (mConditions.isXTSAllSame && - mConditions.isXAMANeutural && - mConditions.isXTDBearishVale && - mConditions.isXTMStartBearish && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceInSignalRange && - ( - // - (mConditions.isXTSAllSame && - mConditions.isXLHLLIncreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // All Bullish ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - mConditions.isXCHLHSameHHs - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - mConditions.isXTDBearishVale - // - || - // - (mConditions.isXTSAllSame && - mConditions.isXLHLLIncreased && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - || - // - (mConditions.isXLHHHSameInLength && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXTDBullOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - (!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXLHHHSameInLength && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) && - ( - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceOverSignal) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentOverFarest) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentCrossedOverNearest) && - ( - // - (mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverMediest) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) && - ( - // - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceOverSignal) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCFastCrossedOverSlow) - // - || - // - (mConditions.isXCHLHSameHHs && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - mConditions.isXCHMAMCVale - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown) - // - || - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXLHLLIncreased) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTSCurrentCrossedOverMediest) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXFICrossedOverZero && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXCHMALCTrendsDown && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXCHMASCCrossedOverMin && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - ((mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) && - ( - // - (mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXTDBearishVale && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedUnderFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentCrossedOverFarest) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD 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) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - !mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXTMEndBullish && - mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - 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.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXCHMASCCrossedOverMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXCHMAMCTrendsUp && - ( - // - mConditions.isXCHMAMCVale - // - || - // - (mConditions.isXTSAllSame && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXAMANeutural && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - mConditions.isXTSCurrentUnderFarest - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentUnderNearest) - // - ) - // - ) - // - || - // - (mConditions.isXTDBearishVale && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMEndBullish && - mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD 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.isXCHMALCVale && - ( - // - (mConditions.isXAMAEndBullish && - mConditions.isXLHHHDecreased && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXTSCurrentUnderFarest) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXLHLLDecreased && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXAMABearish && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXCHMAMCFastUnderSlow) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXTDBearishVale && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMAMCFastUnderSlow && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // 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.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHMAMCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXAMAStartBullish && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - (mConditions.isXTMEndBullish && - mConditions.isXLHLLDecreased && - mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCCrossedOverMax) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - mConditions.isXRSICrossedOverLongExit - // - || - // - (mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - mConditions.isXTSCurrentUnderMediest - // - || - // - (mConditions.isXTSCurrentMax && - ( - // - (mConditions.isXAMANeutural || - mConditions.isXAMAEndBullish) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - mConditions.isXTSCurrentCrossedOverNearest - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXLHLLIncreased) - // - || - // - (mConditions.isXTDBearishVale && - mConditions.isXTDBullOverBear && - mConditions.isXCHMASCCrossedOverMin) - // - || - // - (mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalCrossedOverBear && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXCHMALCTrendsDown && - mConditions.isXTSCurrentUnderNearest) - // - || - // - (mConditions.isXTSCurrentMax && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXFIOverZero && - mConditions.isXAMAStartBullish && - mConditions.isXTSCurrentOverFarest) - // - || - // - (!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXCHLHMCLCHHSame && - ( - // - mConditions.isXTDBearishVale - // - || - // - mConditions.isXCHLHMCLCLLSame - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentOverFarest) && - ( - // - mConditions.isXTSCurrentOverNearest - // - || - // - (mConditions.isXCHMASCCrossedOverMax && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - ((mConditions.isXTSCurrentUnderNearest || - mConditions.isXTSCurrentCrossedUnderNearest) && - (mConditions.isXTSCurrentUnderMediest || - mConditions.isXTSCurrentCrossedUnderMediest)) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXTMEndBullish) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - ((mConditions.isXAMANeutural && - mConditions.isXTMStartBullish) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXLHLLDecreased && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - ((mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentCrossedOverNearest) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale && - mConditions.isXCHMASCCrossedOverMax) - // - || - // - (mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCTrendsDown && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - !mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMALCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - !mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXLHHHDecreased && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentMax && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXCHLHSCMCHHSame && - ( - // - (mConditions.isXCHLHMCLCLLSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - ((mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - mConditions.isXCHMASCCrossedOverMax - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCTrendsDown) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentCrossedUnderNearest && - ( - // - (mConditions.isXLHHighAttachedHH && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXLHLLIncreased && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsDown) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - mConditions.isXRSICrossedOverLongExit - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXLHHighAttachedHH) && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - mConditions.isXCHLHSCMCHHSame - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameHHs && - mConditions.isXTDBearishVale && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - (mConditions.isXCHLHSCMCHHSame && - ( - // - ((mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) && - ( - // - mConditions.isXLHLLIncreased - // - || - // - (mConditions.isXCHMALCVale && - ( - // - mConditions.isXLHHighAttachedHH - // - || - // - mConditions.isXTDSignalCrossedOverBear - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - mConditions.isXTDBearishVale - // - || - // - (mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXLHHighAttachedHH && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXLHHighAttachedHH && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMASCCrossedOverMax) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMAMCFastOverSlow) - // - || - // - (mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - || - // IGnore Cases ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXLHHighAttachedHH && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameHHs) && - ( - // - mConditions.isXCHMASCCrossedOverMax - // - || - // - mConditions.isXTSCurrentCrossedOverMediest - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXLHLLDecreased && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsUp && - mConditions.isXTSCurrentOverNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown) - // - || - // - (mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXLHHHDecreased && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentOverFarest && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXRSICrossedOverLongExit && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXLHHHDecreased && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTMEndBullish && - mConditions.isXTSCurrentMax && - mConditions.isXLHHHDecreased && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - mConditions.isXRSICrossedOverLongExit - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXTSCurrentMax && - mConditions.isXTDBullOverBear && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - mConditions.isXTSCurrentUnderMediest - // - || - // - (mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXTSCurrentMax && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCCrossedOverMin && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXTSAllSame && - mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMALCPeak && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Long ... - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCUnderMax && - mConditions.isXCHMALCTrendsDown) - // - || - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) && - ( - // - (mConditions.isXLHHighAttachedHH && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXRSICrossedOverLongExit && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXLHHighAttachedHH && - mConditions.isXRSICrossedOverLongExit && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCTrendsDown && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) && - ( - // - mConditions.isXLHLLIncreased - // - || - // - mConditions.isXLHHighAttachedHH - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMASCOverMax && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXRSICrossedUnderShortEntry && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXRSICrossedUnderShortEntry && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXCHMAMCFastCrossedOverSlow && - 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 ... - // - // XTD Long ... - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverMediest) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMALCFastUnderSlow && - mConditions.isXCHMASCCrossedOverMin && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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.isXAMANeutural && - mConditions.isXTMStartBullish && - mConditions.isXCHMALCFastOverSlow && - 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) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale && - mConditions.isXTDBullOverBear && - 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 ... - - // - // Common Conditions ... - bool XTDHasShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - mConditions.isXTDSignalCrossedUnderBear - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForShort(mConditions) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XTDHasSpecifiedShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XTDHasShortSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXFICrossedOverZero && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsUp) - // - || - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - || - // - (mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTDBullOverBear) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXAMANeutural || - mConditions.isXAMAEndBullish) && - mConditions.isXTDBullOverBear) - // - || - // - (mConditions.isXCHLHSameLLs && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXTDBullOverBear) - // - || - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXCHMASCTrendsUp && - mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - mConditions.isXCHMASCTrendsUp - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMALCTrendsDown && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTDBullOverBear && - (mConditions.isXAMANeutural || - mConditions.isXTSCurrentOverFarest)) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMALCTrendsUp && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCTrendsUp) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - mConditions.isXCHMAMCTrendsUp - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXFIOverZero && - mConditions.isXTDBullOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXLHLLIncreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Short ... - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - false) - // - ) - // - || - // - // XTD Short ... - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXLHHHDecreased && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMStartBearish && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Short ... - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXLHHHDecreased && - mConditions.isXTDBullOverBear && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Short ... - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - false) - // - ) - // - || - // - // 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.isXCHMASCTrendsUp && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXAMANeutural || - mConditions.isXAMAEndBullish) && - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXTMStartBearish && - mConditions.isXAMAEndBullish && - mConditions.isXAMANeutural && - mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Short ... - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - false) - // - ) - // - || - // - // 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.isXTDBullOverBear && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Short ... - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTDBullOverBear && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHLHSCMCHHSame) && - ( - // - mConditions.isXTSAllSame - // - || - // - mConditions.isXTSCurrentOverFarest - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - // XTD Shorts ... - // Resolve Guard Attacks ... - || - ( - // - // XTD Shorts ... - // isXTSCurrentOverNearest - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXLHLLIncreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Shorts ... - // isXTSCurrentOverMediest - (mConditions.isXTSCurrentOverMediest && - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDBullOverBear && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceUnderSignal && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCVale && - mConditions.isXTDBullOverBear && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Shorts ... - // isXTSCurrentOverFarest - (mConditions.isXTSCurrentOverFarest && - ( - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCFastCrossedUnderSlow) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXLHPriceUnderSignal && - ( - // - ((mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXTSCurrentCrossedUnderNearest) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceUnderSignal && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Shorts ... - // isXTSCurrentOverMediest - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMALCVale && - mConditions.isXLHHHIncreased && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceUnderSignal && - ( - // - (mConditions.isXTMStartBearish && - mConditions.isXTDBullOverBear && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Shorts ... - // isXTDBullOverBear - (mConditions.isXTDBullOverBear && - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDSignalCrossedUnderBear) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMin) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHLHSCMCLLSame && - ( - // - (mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceUnderSignal && - ( - // - (mConditions.isXAMAStartBearish && - mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin) && - ( - // - ((mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCUnderMin && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXAMAStartBearish && - mConditions.isXLHLowAttachedLL) - // - || - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXLHPriceUnderSignal && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXLHPriceCrossedUnderSignal) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - mConditions.isXTMNeutural - // - || - // - mConditions.isXAMANeutural - // - ) - // - ) - // - || - // - (mConditions.isXLHLLSameInLength && - ( - // - (mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXCHMASCFastCrossedUnderSlow && - mConditions.isXTSCurrentCrossedUnderFarest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXLHPriceUnderSignal && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceCrossedUnderSignal && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXLHPriceUnderSignal && - ( - // - (mConditions.isXLHPriceCrossedUnderSignal && - ( - // - ((mConditions.isXTSAllSame && - mConditions.isXLHLowAttachedLL && - mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Shorts ... - // isXCHMASCFastOverSlow - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) && - ( - // - (mConditions.isXLHPriceUnderSignal && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTSAllSame && - ( - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedUnderMediest) && - ( - // - mConditions.isXTDBullOverBear - // - || - // - mConditions.isXTSCurrentCrossedUnderFarest - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceOverSignal && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXLHPriceOverSignal && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCHHSame) && - ( - // - (mConditions.isXTMStartBearish && - ( - // - mConditions.isXAMANeutural - // - || - // - mConditions.isXAMAStartBearish - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXLHHHIncreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXTMStartBearish && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Shorts ... - // isXCHMAMCFastOverSlow - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) && - ( - // - ((mConditions.isXTSCurrentMin && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - || - // - (((mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) || - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish)) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXLHLLIncreased && - mConditions.isXLHLowAttachedLL && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHPriceCrossedUnderSignal && - mConditions.isXCHMASCFastCrossedUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Shorts ... - // isXCHMALCFastOverSlow - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMin && - mConditions.isXLHHHDecreased && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - || - // - // XTD Shorts ... - // isXCHMASCTrendsDown - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXLHHHSameInLength && - ( - // - (mConditions.isXLHPriceUnderSignal && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Shorts ... - // isXCHMALCTrendsDown - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTMStartBearish && - mConditions.isXLHLowAttachedLL && - mConditions.isXAMAStartBearish && - mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - || - // - // XTD Shorts ... - // Bearish MA ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDSignalCrossedUnderBear) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - mConditions.isXTSCurrentCrossedUnderFarest - // - || - // - mConditions.isXTSCurrentCrossedUnderNearest - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXAMAEndBearish && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCTrendsDown && - mConditions.isXTDSignalCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXTSCurrentMin && - mConditions.isXTSCurrentCrossedUnderFarest) && - ( - // - (mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXTMStartBearish && - mConditions.isXCHMASCFastCrossedUnderSlow && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Short ... - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - false) - // - ) - // - || - // - // 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.isXTDBullOverBear && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow && - mConditions.isXCHMASCFastCrossedUnderSlow && - mConditions.isXTSCurrentCrossedUnderFarest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXTDBullOverBear && - mConditions.isXCHMASCTrendsUp) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Short ... - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXCHMASCTrendsUp && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Short ... - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - (mConditions.isXLHHHIncreased && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXTDBullOverBear) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXTDBullOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXTDBullOverBear && - mConditions.isXAMAStartBearish && - mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Short ... - // PriceUnderSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXLHLowAttachedLL && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXCHMASCTrendsUp && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMASCTrendsUp && - mConditions.isXTSCurrentOverFarest) - // - || - // - ((mConditions.isXAMABullish && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - mConditions.isXCHLHMCLCLLSame - // - || - // - (mConditions.isXTSCurrentCrossedUnderFarest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsUp) && - ( - // - (((mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural)) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXTDBullOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXAMABullish && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXLHLLIncreased && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest) && - ( - // - (mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXLHHHIncreased && - mConditions.isXCHMALCFastUnderSlow && - mConditions.isXTDSignalCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Short ... - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXCHMALCTrendsUp && - mConditions.isXCHMALCFastUnderSlow) - // - || - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDBullOverBear) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXTDSignalCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Short ... - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXCHMASCTrendsUp) && - ( - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXTDBullOverBear && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCFastCrossedUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMASCFastOverSlow) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTD Short ... - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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.isXCHMALCVale && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXCHMASCTrendsDown && - mConditions.isXTSCurrentOverNearest && - mConditions.isXCHMASCFastCrossedUnderSlow) - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXTSCurrentCrossedUnderFarest) - // - ) - // - ) - // - || - // - // 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 ... - - // - // Common Conditions ... - bool XTAMHasLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - (mConditions.amas[1] > mConditions.tms[1] && - mConditions.amas[2] > mConditions.tms[2]) - // - && - // - !(mConditions.amas[2] > mConditions.tms[2] && - mConditions.amas[3] > mConditions.tms[3]) - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForLong(mConditions) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XTAMHasSpecifiedLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XTAMHasLongSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCVale && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXLHLLIncreased && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentMax) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCVale && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCPeak && - (mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - ((mConditions.isXCHMAMCVale && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) && - (mConditions.isXCHMALCVale && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow))) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMAMCVale && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMax && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHMCLCLLSame) - // - || - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXTMEndBearish && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHLHSCMCLLSame && - (mConditions.isXTSCurrentUnderFarest || - mConditions.isXTSCurrentUnderMediest)) - // - || - // - (mConditions.isXCHLHMCLCHHSame && - (mConditions.isXTSCurrentUnderNearest || - mConditions.isXTSCurrentCrossedUnderNearest)) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTSAllSame && - mConditions.isXCHMASCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ( - (mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check Conditions if Price is Over Signal ... - ( - // - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // Next Step is to Check LL and HH Same Style ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMax && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedOverFarest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - ( - // - mConditions.isXLHHHDecreased - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBearishVale) - // - ) - // - ) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCFastCrossedOverSlow) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTMStartBullish && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXAMAStartBullish && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale || - mConditions.isXCHLHSameHHs) && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHLHSameHHs && - mConditions.isXLHLLDecreased && - mConditions.isXLHHighAttachedHH) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCPeak && - (mConditions.isXCHMAMCTrendsDown || - mConditions.isXCHMAMCFastUnderSlow)) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBearish && - mConditions.isXAMANeutural && - mConditions.isXAMAEndBearish && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXFICrossedOverZero && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentMax && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - false) - // - ) - // - || - // - // 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.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXTDSignalUnderBear && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXLHHHIncreased && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - false) - // - ) - // - || - // - // XTAM Long ... - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // XTAM Long ... - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXLHHighAttachedHH) && - ( - // - mConditions.isXCHLHSameHHs - // - || - // - (mConditions.isXTDSignalUnderBear && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - // XTAM Long ... - // Resolve Guard Attacks ... - || - // - ( - // - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXFIUnderZero && - mConditions.isXLHHHIncreased && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - mConditions.isXCHMASCTrendsUp - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXLHHHDecreased) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDSignalCrossedUnderBear && - ( - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMALCPeak && - mConditions.isXFIUnderZero && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXFICrossedUnderZero) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXLHHHIncreased && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTSAllSame && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXLHLLIncreased) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXLHHHDecreased && - mConditions.isXCHLHSCMCLLSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXTDBearishVale && - mConditions.isXTMVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCHHSame) && - ( - // - mConditions.isXTSCurrentMax - // - || - // - mConditions.isXTSCurrentUnderFarest - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDBearishVale && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMax) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - mConditions.isXCHMALCVale - // - || - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTDSignalUnderBear && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXCHMASCFastCrossedOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBearishVale && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXLHHighAttachedHH) && - ( - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXTMVale && - mConditions.isXCHMASCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) && - ( - // - mConditions.isXTSCurrentMax - // - || - // - mConditions.isXCHMASCCrossedOverMax - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentUnderNearest) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCHHSame) && - ( - // - (mConditions.isXCHMASCOverMax && - ( - // - mConditions.isXRSICrossedOverLongExit - // - || - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // All Bullish ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMAMCFastCrossedOverSlow && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalUnderBear && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - || - // - (mConditions.isXLHHighAttachedHH && - ( - // - (mConditions.isXCHLHSameHHs && - ( - // - mConditions.isXTDBearishVale - // - || - // - (mConditions.isXCHLHMCLCLLSame && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCFastCrossedOverSlow && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHLHSCMCHHSame) - // - || - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXAMAStartBullish && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXRSICrossedOverLongExit && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXCHMAMCFastCrossedOverSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTSCurrentUnderFarest) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXCHMASCOverMax && - mConditions.isXTMStartBullish && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTDSignalUnderBear && - mConditions.isXTDBullCrossedUnderBear) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSAllSame && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCCrossedUnderMax) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCCrossedUnderMax) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXTMVale && - mConditions.isXCHMASCVale && - mConditions.isXLHLLDecreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) && - ( - // - mConditions.isXTDBearishVale - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXTSCurrentCrossedUnderNearest && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame) - // - || - // - (mConditions.isXCHLHSameHHs && - mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCCrossedOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - mConditions.isXTSAllSame - // - || - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalUnderBear && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // PriceInSignalRange ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXLHLowAttachedLL && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMAMCTrendsUp) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - mConditions.isXTDSignalUnderBear - // - || - // - (mConditions.isXTDBearishVale && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXLHHHDecreased) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) - // - || - // - (mConditions.isXCHMAMCTrendsUp && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXCHMASCVale && - mConditions.isXCHMASCTrendsUp) && - ( - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXLHLLIncreased && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTDBullUnderBear) - // - || - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // PriceUnderSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - (mConditions.isXCHLHSameHHs && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXTSCurrentCrossedOverNearest) && - ( - // - mConditions.isXCHLHMCLCLLSame - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXLHLLIncreased && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCCrossedOverMin && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXRSICrossedOverLongExit && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale) && - ( - // - (mConditions.isXTSCurrentCrossedOverNearest && - ( - // - mConditions.isXCHMALCVale - // - || - // - (mConditions.isXLHHHDecreased && - mConditions.isXCHMASCCrossedOverMax) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale && - mConditions.isXLHHighAttachedHH) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXCHMASCPeak && - mConditions.isXCHMASCOverMax) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXLHHighAttachedHH && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHLLIncreased && - mConditions.isXCHMALCTrendsUp && - mConditions.isXCHMALCFastOverSlow) - // - || - // - (mConditions.isXCHMASCOverMax && - mConditions.isXTDBullUnderBear && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXLHLLIncreased && - mConditions.isXTDSignalUnderBear && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - || - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Long ... - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - - // - // Common Conditions ... - bool XTAMHasShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - (mConditions.amas[1] < mConditions.amas[1] && - mConditions.amas[2] < mConditions.amas[2]) - // - && - // - !(mConditions.amas[2] < mConditions.amas[2] && - mConditions.amas[3] < mConditions.amas[3]) - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForShort(mConditions) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XTAMHasSpecifiedShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XTAMHasShortSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXFIOverZero && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentOverFarest) - // - || - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMNeutural || - mConditions.isXTMEndBullish) && - mConditions.isXAMABullish && - mConditions.isXFIOverZero && - mConditions.isXTDBullOverBear) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMASCTrendsUp && - mConditions.isXTSCurrentOverNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMASCTrendsUp) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - || - // - (mConditions.isXFIOverZero && - mConditions.isXCHMASCPeak && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ( - // - mConditions.isXCHMAMCTrendsUp - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCVale && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMALCTrendsUp && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXFIOverZero && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTSCurrentMin && - mConditions.isXCHMALCTrendsUp && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - || - // - ((mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXTSCurrentMin) && - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - mConditions.isXTDBullishVale - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL) && - ( - // - mConditions.isXCHMALCTrendsDown - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - (mConditions.isXAMAVale && - mConditions.isXTMBearish && - mConditions.isXCHMASCVale && - mConditions.isXAMABearish && - mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCTrendsUp && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - (mConditions.isXAMAVale && - mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMASCVale && - mConditions.isXTSCurrentMin && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTSCurrentMin && - mConditions.isXLHLowAttachedLL) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHMAMCTrendsUp) - // - || - // - (mConditions.isXCHMASCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDSignalVale && - mConditions.isXTSCurrentMin && - mConditions.isXTDBullishVale) && - ( - // - (mConditions.isXTSAllSame && - mConditions.isXLHHHDecreased && - mConditions.isXCHLHSCMCLLSame) - // - || - // - (mConditions.isXLHLowAttachedLL && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check Conditions if Price is Over Signal ... - ( - // - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // Next Step is to Check LL and HH Same Style ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentOverFarest) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear) && - ( - // - (mConditions.isXCHMASCTrendsUp && - mConditions.isXTDSignalOverBear) - // - || - // - (mConditions.isXFIOverZero && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsUp) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - (mConditions.isXTDBullOverBear || - mConditions.isXTSCurrentOverFarest)) - // - || - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - (mConditions.isXTSCurrentOverFarest || - mConditions.isXTSCurrentOverMediest)) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMin && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMASCTrendsUp) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXFIOverZero && - mConditions.isXCHMALCVale && - mConditions.isXLHHHIncreased && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMAMCTrendsUp) - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXTDSignalUnderBear && - mConditions.isXFICrossedUnderZero && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXCHMASCTrendsUp && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // XTAM Short ... - // PriceUnderSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTDSignalOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTDBullCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - ) - // - ) - // - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMASCTrendsUp && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - // XTAM Short ... - // Resolve Guard Attacks ... - || - // - ( - // - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMin) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDSignalUnderBear && - mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCCrossedUnderMin) && - ( - // - mConditions.isXTSCurrentOverFarest - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXTDSignalOverBear) && - ( - // - mConditions.isXTDBullOverBear - // - || - // - (mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSAllSame && - mConditions.isXLHLLDecreased) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXLHLLIncreased) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXLHLLIncreased) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXRSICrossedUnderShortExit && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMin && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMVale && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMALCVale && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - mConditions.isXTSCurrentMax - // - || - // - mConditions.isXTDSignalOverBear - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalCrossedOverBear && - ( - // - (mConditions.isXAMABullish && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceCrossedOverSignal && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMALCVale && - ( - // - mConditions.isXCHMASCUnderMin - // - || - // - mConditions.isXCHLHMCLCLLSame - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - || - // - ((mConditions.isXCHMASCPeak && - mConditions.isXTDSignalOverBear) && - ( - // - mConditions.isXCHMASCTrendsUp - // - || - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) && - ( - // - ((mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDBullCrossedOverBear) - // - || - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCOverMax && - mConditions.isXLHHHIncreased && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCHHSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalCrossedOverBear && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCTrendsUp && - mConditions.isXTSCurrentOverFarest) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXTSAllSame && - mConditions.isXLHHighAttachedHH) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTMNeutural && - ( - // - ((mConditions.isXAMANeutural && - mConditions.isXTSCurrentMin) && - ( - // - mConditions.isXTSCurrentCrossedUnderFarest - // - || - // - (mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) - // - ) - // - ) - // - || - // - ((mConditions.isXAMABullish && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest) && - ( - // - mConditions.isXTDSignalOverBear - // - || - // - (mConditions.isXTMBullish && - mConditions.isXTSCurrentMax && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // All Bearish ... - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDBullOverBear && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMASCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXTSCurrentCrossedUnderNearest) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish && - mConditions.isXLHPriceCrossedUnderSignal && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - || - // - ((mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentCrossedOverNearest) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameLLs) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMin && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCCrossedUnderMin) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCCrossedUnderMax) && - ( - // - (!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTSCurrentMin && - mConditions.isXTDBullishVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXLHHHDecreased && - mConditions.isXCHMASCCrossedUnderMax) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXRSICrossedUnderShortExit && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL) && - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - ( - // - ((mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL && - mConditions.isXCHMASCCrossedUnderMin) && - ( - // - (mConditions.isXTMVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHPriceCrossedUnderSignal && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXRSICrossedUnderShortExit && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXAMAStartBearish && - mConditions.isXLHLowAttachedLL && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullUnderBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - || - // - ((mConditions.isXTSCurrentMin && - mConditions.isXLHLowAttachedLL) && - ( - // - mConditions.isXCHMAMCFastCrossedUnderSlow - // - || - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentCrossedUnderFarest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTAM Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSAllSame && - mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTDBullOverBear && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTSCurrentOverFarest && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXAMABullish && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXTSCurrentOverFarest && - mConditions.isXCHMASCCrossedOverMin) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentCrossedUnderFarest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXTDBullOverBear && - mConditions.isXCHMAMCTrendsUp) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCHHSame) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // PriceInSignalRange ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsDown && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) && - ( - // - ((mConditions.isXCHLHSameLLs && - mConditions.isXLHLowAttachedLL) && - ( - // - mConditions.isXTSCurrentOverFarest - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMASCTrendsUp && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXLHPriceCrossedUnderSignal && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // PriceUnderSignal ... - // 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.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow && - mConditions.isXLHPriceCrossedUnderSignal && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMin && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTMVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - || - // - (mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXTDBullUnderBear && - mConditions.isXLHLowAttachedLL && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin) && - ( - // - ((mConditions.isXTMVale && - mConditions.isXAMAVale) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL && - mConditions.isXCHMASCCrossedUnderMin) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXLHLowAttachedLL && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - (mConditions.isXTMVale && - mConditions.isXCHMASCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentOverNearest && - mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMVale && - mConditions.isXAMAVale) && - ( - // - (mConditions.isXTDSignalVale && - mConditions.isXTSCurrentMin && - mConditions.isXTDBullishVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXCHLHSameLLs && - ( - // - (mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - || - // - (!mConditions.isXCHMALCTrendsUp && - !mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXLHLowAttachedLL && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - || - // - ((mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - mConditions.isXCHLHSameLLs - // - || - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - || - // - (mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastCrossedUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // PriceUnderSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - ((mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL && - mConditions.isXTDBullCrossedUnderBear && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXLHLLDecreased && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL && - mConditions.isXLHPriceCrossedUnderSignal && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMAMCTrendsDown) && - ( - // - mConditions.isXTSCurrentOverFarest - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXTSCurrentCrossedUnderFarest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM 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.isXTMEndBullish && - mConditions.isXAMAEndBullish) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXTSCurrentCrossedUnderFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTDSignalOverBear && - ( - // - ((mConditions.isXTSCurrentOverMediest || - mConditions.isXTSCurrentOverNearest) && - ( - // - mConditions.isXTSCurrentOverFarest - // - || - // - (mConditions.isXCHMASCTrendsUp && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXRSICrossedOverLongExit) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - mConditions.isXTSCurrentOverFarest - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXTSCurrentCrossedUnderFarest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXTSCurrentOverNearest && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTAM Short ... - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - - // - // Common Conditions ... - bool XSIHasLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - mConditions.isXRSICrossedOverLongEntry && - mConditions.rsis[3] < mInputs.rsiInputs.longEntryValue - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForLong( - mConditions, - true, // XCHMA Min - true, // XCHMA Max - true, // XCHMA Cycles - true, // XCHMA Peaks - false, // XCHMA Trend Powers - true, // XOBD - true // XTS - ) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XSIHasSpecifiedLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XSIHasLongSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - (mConditions.isXTSAllSame && - mConditions.isXCHLHSameLLs && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - || - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXAMANeutural && - mConditions.isXLHHHDecreased && - mConditions.isXTMStartBullish && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentUnderFarest) - // - || - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXTMStartBullish) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXTSCurrentMax) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - (mConditions.isXAMANeutural || - mConditions.isXAMAEndBearish)) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMANeutural && - mConditions.isXAMAEndBullish && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - || - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXAMAEndBearish && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest) - // - || - // - ((mConditions.isXTMVale && - mConditions.isXAMAVale) - // - && - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale) - // - && - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame)) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) - // - || - // - (mConditions.isXTMVale && - mConditions.isXTMNeutural && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXAMAStartBullish && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale) - // - || - // - (mConditions.isXLHHHDecreased && - mConditions.isXLHLLDecreased) - // - || - // - ((mConditions.isXTMVale || - mConditions.isXTMNeutural || - mConditions.isXTMEndBearish) && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHLHSCMCLLSame) - // - || - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - || - // - (mConditions.isXCHMASCVale && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check Conditions if Price is Over Signal ... - ( - // - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // Next Step is to Check LL and HH Same Style ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // Exceptions: - // there some commonly Exceptions which makes our choice incorrect, - // here we are combined knownly Exceptions ... - !( - // - // XSI Long ... - // Resolve Stop Outs ... - ( - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXCHMALCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - mConditions.isXTSCurrentUnderFarest - // - || - // - mConditions.isXTSCurrentCrossedUnderNearest - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (((mConditions.isXTMVale && - mConditions.isXAMAVale) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural)) && - ( - // - mConditions.isXTSCurrentUnderFarest - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXCHMALCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - mConditions.isXCHMAMCVale - // - ) - // - ) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - // XSI Long ... - // Resolve Guard Attacks ... - || - // - ( - // - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTMVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTMVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXCHMAMCTrendsUp) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale) && - ( - // - mConditions.isXTSCurrentUnderMediest - // - || - // - mConditions.isXTSCurrentUnderFarest - // - || - // - ((mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXTMBearish && - mConditions.isXAMANeutural && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXCHMASCFastCrossedOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - ((mConditions.isXCHLHMCLCLLSame && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXLHHHDecreased && - mConditions.isXLHLLDecreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - ((mConditions.isXTMVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame) && - ( - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish)) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMALCPeak) && - ( - // - (mConditions.isXTSAllSame && - mConditions.isXCHMAMCVale) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMASCVale) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTMVale && - mConditions.isXCHMASCVale && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTMBearish && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXCHLHSCMCLLSame && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTMBearish && - mConditions.isXCHMAMCVale && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMin && - mConditions.isXAMAEndBearish) - // - || - // - (mConditions.isXCHLHMCLCHHSame && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale) - // - || - // - ((mConditions.isXTMVale && - mConditions.isXTMBearish && - mConditions.isXCHMASCVale) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXLHLLDecreased) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXTSCurrentCrossedUnderNearest && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXLHLLDecreased && - mConditions.isXCHMALCTrendsUp && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXCHMASCFastCrossedOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTMVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCLLSame) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCLLSame) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXAMAVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCLLSame) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXTMVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXTDSignalCrossedUnderBear) - // - ) - // - ) - // - || - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Long ... - // PriceInSignalRange ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXCHMASCVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXCHMAMCFastOverSlow) - // - || - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXTSAllSame && - mConditions.isXAMABearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMAMCTrendsUp) - // - || - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXTSAllSame && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTDSignalUnderBear && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXCHMALCFastOverSlow) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - || - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXCHMASCFastCrossedOverSlow) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMax && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXCHMALCFastOverSlow) - // - || - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXRSICrossedOverLongEntry) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTDSignalUnderBear && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - - // - // Common Conditions ... - bool XSIHasShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - mConditions.isXRSICrossedUnderShortEntry && - mConditions.rsis[3] > mInputs.rsiInputs.shortEntryValue - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForShort( - mConditions, - true, // XCHMA Min - true, // XCHMA Max - true, // XCHMA Cycles - true, // XCHMA Peaks - false, // XCHMA Trend Powers - true, // XOBD - true // XTS - ) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XSIHasSpecifiedShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XSIHasShortSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXLHHHIncreased && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXLHHHIncreased && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXFIOverZero && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTDSignalOverBear) - // - || - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBullish && - (mConditions.isXAMANeutural || - mConditions.isXAMAEndBullish)) && - mConditions.isXFIOverZero && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXLHHHIncreased && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - || - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXAMABearish && - mConditions.isXTSCurrentMin && - mConditions.isXTMStartBearish && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTSCurrentCrossedUnderFarest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - )) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) - // - || - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentOverNearest) - // - || - // - (((mConditions.isXTMBullish || - mConditions.isXTMStartBullish) && - (mConditions.isXAMABullish || - mConditions.isXAMAStartBullish)) && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXLHHHIncreased && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXFIOverZero) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXFIOverZero && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCHHSame) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXTMEndBullish && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXAMAStartBearish) - // - || - // - ((mConditions.isXCHMASCPeak && - mConditions.isXTSCurrentOverFarest) && - ( - // - mConditions.isXTMNeutural - // - || - // - mConditions.isXTSCurrentOverMediest - // - || - // - (mConditions.isXTMBullish && - mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXLHHHIncreased) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - || - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) && - ( - // - (mConditions.isXLHHHIncreased && - mConditions.isXLHLLIncreased) - // - || - // - (mConditions.isXCHLHSCMCHHSame && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXTSCurrentMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXLHHHIncreased && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsUp) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - (mConditions.isXTDSignalOverBear || - mConditions.isXTDSignalCrossedOverBear)) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - (mConditions.isXFIOverZero || - mConditions.isXTSCurrentOverFarest)) - // - || - // - (mConditions.isXAMABullish && - mConditions.isXFIOverZero && - mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCTrendsUp) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMASCTrendsUp) - // - || - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // Exceptions: - // there some commonly Exceptions which makes our choice incorrect, - // here we are combined knownly Exceptions ... - !( - // - // XSI Short ... - // Resolve Stop Outs ... - ( - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTMBullish && - mConditions.isXCHMALCVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXLHHHIncreased && - mConditions.isXCHMAMCFastCrossedOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDSignalOverBear && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak) && - ( - // - (mConditions.isXLHHHIncreased && - ( - // - (mConditions.isXCHLHSCMCHHSame && - ( - // - mConditions.isXTSCurrentOverFarest - // - || - // - mConditions.isXCHMAMCFastCrossedOverSlow - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - mConditions.isXTSCurrentOverFarest - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXTSCurrentOverNearest && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCCrossedOverMin && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMBullish && - mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXAMAEndBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMASCPeak && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXTDBearishVale && - mConditions.isXLHHHIncreased && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMASCPeak && - ( - // - mConditions.isXCHMAMCPeak - // - || - // - mConditions.isXCHMALCVale - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - mConditions.isXCHMAMCFastCrossedOverSlow - // - || - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXCHMAMCFastCrossedOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXLHHHIncreased && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - // XSI Short ... - // Resolve Guard Attacks ... - || - // - ( - // - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - mConditions.isXCHMASCPeak - // - || - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) && - ( - // - ((mConditions.isXTSAllSame && - mConditions.isXLHHHIncreased && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXLHHHIncreased && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentOverFarest) - // - || - // - ((mConditions.isXTSCurrentMin && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale) && - ( - // - ((mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCHHSame) && - ( - // - mConditions.isXTSCurrentCrossedUnderNearest - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXLHHHIncreased) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMASCPeak && - ( - // - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCPeak && - ( - // - ((mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHLHSCMCHHSame && - ( - // - mConditions.isXCHLHMCLCLLSame - // - || - // - mConditions.isXTSCurrentOverMediest - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXLHHHIncreased && - mConditions.isXCHLHSCMCHHSame) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCLLSame) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - mConditions.isXCHLHMCLCLLSame - // - || - // - mConditions.isXTSCurrentOverMediest - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame) - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak) && - ( - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - ((mConditions.isXLHHHIncreased && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMin && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXTDBearishVale && - mConditions.isXLHHHDecreased && - mConditions.isXLHLLDecreased && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMAMCFastCrossedOverSlow && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCFastCrossedOverSlow && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XSI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXLHHHIncreased && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCOverMax && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // PriceInSignalRange ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentOverFarest && - mConditions.isXRSICrossedUnderShortExit && - mConditions.isXRSICrossedUnderShortEntry) - // - || - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow && - mConditions.isXCHMAMCFastUnderSlow && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXCHLHSameLLs && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXLHPriceCrossedUnderSignal) - // - || - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTSCurrentOverFarest && - mConditions.isXCHMAMCFastUnderSlow && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak) && - ( - // - mConditions.isXTSCurrentOverFarest - // - || - // - (mConditions.isXTSAllSame && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - || - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCTrendsUp) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow && - mConditions.isXCHMASCCrossedOverMin) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - ((mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentCrossedUnderFarest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - || - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XSI Short ... - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMASCFastUnderSlow && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - (mConditions.isXLHHHIncreased && - mConditions.isXTSCurrentOverFarest && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXLHHHIncreased && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTSCurrentOverFarest && - 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - - // - // Common Conditions ... - bool XTSFIHasLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - double tsValues[] = { - mConditions.tsCurrents[1], - mConditions.tsNearests[1], - mConditions.tsMediests[1], - mConditions.tsFarests[1], - }; - - // - double tsMin = GetMin(tsValues); - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - tsMin == mConditions.tsFarests[1] && - (mConditions.isXTSCurrentOverFarest || - mConditions.isXTSCurrentCrossedOverFarest) && - (mConditions.tsCurrents[1] < mConditions.tsNearests[1] || - mConditions.tsCurrents[1] < mConditions.tsMediests[1]) && - !(mConditions.isXTSCurrentUnderNearest || - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForLong(mConditions) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XTSFIHasSpecifiedLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XTSFIHasLongSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXAMAEndBearish && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXTSCurrentUnderMediest) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXTDSignalUnderBear && - mConditions.isXFICrossedUnderZero) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMNeutural && - (mConditions.isXAMANeutural || - mConditions.isXAMAEndBullish) && - mConditions.isXCHLHSameHHs && - mConditions.isXLHLLIncreased && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTDBearishVale && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTDSignalUnderBear && - mConditions.isXFICrossedUnderZero && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMASCPeak && - (mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMAMCTrendsDown && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCOverMin && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - mConditions.isXCHMALCVale - // - || - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXAMAStartBullish) - // - || - // - (mConditions.isXLHLLDecreased && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXTMNeutural || - mConditions.isXTMStartBullish) && - mConditions.isXLHHHDecreased && - (mConditions.isXAMANeutural || - mConditions.isXAMAStartBearish) && - mConditions.isXTSCurrentUnderMediest) - // - || - // - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - mConditions.isXCHMALCVale - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMASCPeak && - (mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCPeak && - (mConditions.isXAMANeutural || - mConditions.isXAMAEndBullish)) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXCHMALCVale && - (mConditions.isXAMANeutural || - mConditions.isXAMAEndBullish) && - mConditions.isXTMStartBearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentUnderMediest) && - ( - // - mConditions.isXCHMALCVale - // - || - // - (mConditions.isXCHMALCTrendsDown && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMASCPeak && - (mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCVale && - mConditions.isXAMAStartBullish && - mConditions.isXFICrossedOverZero && - mConditions.isXTDBullCrossedOverBear && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMAMCPeak && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // Exceptions: - // there some commonly Exceptions which makes our choice incorrect, - // here we are combined knownly Exceptions ... - !( - // - // XTSFI Long ... - // Resolve Stop Outs ... - ( - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCTrendsUp) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXTMStartBullish) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Neutural States ... - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCCrossedOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDBullCrossedUnderBear && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // All Bullish ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTMBearish && - mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMASCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXFICrossedUnderZero) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDBearishVale && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCOverMin && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCUnderMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame) && - ( - // - mConditions.isXAMABearish - // - || - // - mConditions.isXAMANeutural - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check Bearish State ... - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) && - ( - // - mConditions.isXTMBearish - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check Bearish State ... - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) && - ( - // - mConditions.isXTMBearish - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBearish && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - // XTSFI Long ... - // Resolve Guard Attacks ... - || - // - ( - // - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDBullCrossedUnderBear && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXLHHHIncreased && - mConditions.isXCHMASCOverMax) && - ( - // - mConditions.isXCHLHMCLCHHSame - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXTMStartBullish && - mConditions.isXCHLHMCLCHHSame) - // - || - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCOverMax) - // - || - // - ((!mConditions.isXCHMALCTrendsUp && - !mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCCrossedOverMax) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDSignalCrossedUnderBear && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXCHMALCPeak && - mConditions.isXLHHHIncreased && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXFIUnderZero && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) && - ( - // - (mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak) && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - || - // - (mConditions.isXFIUnderZero && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMALCTrendsUp && - !mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHLHSameHHs && - mConditions.isXTMEndBullish && - mConditions.isXCHMASCOverMax) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDSignalCrossedUnderBear) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBullish && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXAMANeutural && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMAEndBullish) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXLHLLIncreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMALCTrendsUp && - !mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXFIUnderZero && - mConditions.isXFICrossedUnderZero && - mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXCHMASCOverMax && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXCHMASCOverMax && - mConditions.isXRSICrossedOverLongExit && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTDBullUnderBear && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTDBullUnderBear && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMANeutural && - mConditions.isXAMAEndBearish && - mConditions.isXCHMASCOverMax) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMABearish) && - ( - // - mConditions.isXTMEndBearish - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - || - // - (mConditions.isXFIUnderZero && - mConditions.isXLHHHDecreased && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXCHMALCPeak) && - ( - // - (mConditions.isXAMAVale && - ( - // - (mConditions.isXCHLHSCMCLLSame && - ( - // - mConditions.isXCHMAMCVale - // - || - // - mConditions.isXCHLHMCLCHHSame - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHMASCUnderMax && - mConditions.isXCHMASCCrossedUnderMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - (mConditions.isXCHMALCVale && - ( - // - ((mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXAMABearish) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBullish && - mConditions.isXTDBearishVale) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXAMANeutural && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - mConditions.isXTMBearish - // - || - // - mConditions.isXTMNeutural - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalCrossedUnderBear && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHMCLCHHSame) - // - || - // - (mConditions.isXFIUnderZero && - mConditions.isXFICrossedUnderZero && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXCHMAMCVale) && - ( - // - (mConditions.isXAMABearish && - mConditions.isXCHMALCPeak && - mConditions.isXTMEndBullish) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXLHHHDecreased && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalCrossedUnderBear && - ( - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTDSignalCrossedUnderBear && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) && - ( - // - ( - mConditions.isXCHMASCUnderMin && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - mConditions.isXTDBullOverBear - // - || - // - mConditions.isXTDSignalUnderBear - // - || - // - mConditions.isXTDSignalCrossedUnderBear - // - || - // - (mConditions.isXFIUnderZero && - mConditions.isXFICrossedUnderZero) - // - ) - // - ) - // - || - // - (mConditions.isXTMNeutural && - ( - // - mConditions.isXLHPriceCrossedUnderSignal - // - || - // - (mConditions.isXAMANeutural && - ( - // - mConditions.isXTDSignalUnderBear - // - || - // - (mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - || - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTDBullUnderBear && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Otherwise ... - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXTMStartBullish && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCTrendsUp) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTDBullCrossedUnderBear && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - || - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXLHHHIncreased && - mConditions.isXCHMASCOverMax && - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - mConditions.isXRSICrossedUnderShortExit - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCOverMax && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown) && - ( - // - (mConditions.isXLHHHIncreased && - mConditions.isXCHMASCOverMax && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXRSICrossedUnderShortExit) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCHHSame) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMStartBullish && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXTMNeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax) - // - || - // - (mConditions.isXFIUnderZero && - mConditions.isXCHMASCOverMax && - mConditions.isXFICrossedUnderZero) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXCHLHMCLCLLSame) && - ( - // - mConditions.isXTMEndBullish - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXAMAEndBullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCOverMax && - ( - // - mConditions.isXCHLHSCMCHHSame - // - || - // - (mConditions.isXTDBearishVale && - ( - // - mConditions.isXTSCurrentCrossedOverNearest - // - || - // - mConditions.isXTSCurrentCrossedUnderMediest - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHLHMCLCHHSame && - ( - // - mConditions.isXCHLHMCLCLLSame - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXLHLLIncreased) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale && - mConditions.isXLHHHDecreased && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // All Bullish ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMASCOverMax && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCHHSame) - // - || - // - (mConditions.isXCHLHSameHHs && - mConditions.isXCHLHSameLLs && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXLHLLDecreased && - mConditions.isXCHLHSCMCHHSame) - // - || - (mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - (mConditions.isXTDSignalCrossedOverBear && - ( - // - mConditions.isXCHLHMCLCHHSame - // - || - // - mConditions.isXTSCurrentCrossedOverNearest - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXLHLLDecreased && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - (mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXLHHHDecreased) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // All Neutural ... - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - mConditions.isXRSICrossedOverLongExit - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCCrossedOverMax) && - ( - // - (mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXCHMALCPeak) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXFIUnderZero && - mConditions.isXCHMASCUnderMin && - mConditions.isXFICrossedUnderZero && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXLHHHDecreased && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTMEndBullish && - mConditions.isXLHHHDecreased && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXAMAEndBullish) - // - ) - // - ) - // - || - // - ((mConditions.isXFIUnderZero && - mConditions.isXFICrossedUnderZero) && - ( - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTSCurrentCrossedOverNearest && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - || - // - mConditions.isXTDSignalCrossedOverBear - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXLHHHDecreased && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCCrossedOverMax) - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - mConditions.isXCHLHSCMCHHSame - // - || - // - mConditions.isXTDSignalCrossedUnderBear - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalCrossedUnderBear && - ( - // - (mConditions.isXCHLHSCMCHHSame && - ( - // - mConditions.isXCHLHMCLCLLSame - // - || - // - mConditions.isXRSICrossedOverLongExit - // - || - // - (!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXTDSignalOverBear && - ( - // - (mConditions.isXCHMASCOverMax && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHLHSCMCHHSame) && - ( - // - mConditions.isXCHLHMCLCLLSame - // - || - // - mConditions.isXCHMALCTrendsDown - // - ) - // - ) - // - || - // - ((mConditions.isXCHLHSameHHs && - mConditions.isXTDBearishVale) && - ( - // - mConditions.isXLHHHIncreased - // - || - // - mConditions.isXTSCurrentCrossedOverNearest - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) && - ( - // - (mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // All Bullish ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax) && - ( - // - mConditions.isXRSICrossedOverLongExit - // - || - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest) - // - || - // - (mConditions.isXAMAStartBullish && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXTDSignalCrossedOverBear && - ( - // - mConditions.isXCHLHSCMCHHSame - // - || - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // All Bearish ... - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCLLSame) && - ( - // - mConditions.isXCHLHMCLCHHSame - // - || - // - mConditions.isXTSCurrentCrossedOverNearest - // - ) - // - ) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMALCTrendsUp && - !mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCLLSame) && - ( - // - mConditions.isXTMNeutural - // - || - // - mConditions.isXAMANeutural - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXFIUnderZero && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) && - ( - // - mConditions.isXAMANeutural - // - || - // - (mConditions.isXTMNeutural && - ( - // - (mConditions.isXAMABearish && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXTMEndBullish && - mConditions.isXLHLLIncreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - mConditions.isXTDBullCrossedUnderBear - // - || - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXLHLLIncreased && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) - // - || - // - (mConditions.isXTDBearishVale && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentOverFarest) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCHHSame) - // - || - // - (!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXTMEndBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - mConditions.isXTDBearishVale - // - || - // - mConditions.isXCHLHMCLCHHSame - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) && - ( - // - (mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMStartBullish && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXFIUnderZero && - mConditions.isXCHMASCOverMax && - mConditions.isXFICrossedUnderZero) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // All Neutural ... - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTDBullCrossedUnderBear && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTDBullCrossedUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXFIUnderZero && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXFICrossedUnderZero) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXLHPriceCrossedUnderSignal && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTMBearish && - mConditions.isXCHMAMCPeak && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // All Bullish ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - mConditions.isXTSCurrentUnderMediest - // - ) - // - ) - // - || - // - ((mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) && - ( - // - mConditions.isXTDBullUnderBear - // - || - // - mConditions.isXTDBullCrossedUnderBear - // - ) - // - ) - // - || - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCTrendsDown && - mConditions.isXTSCurrentUnderMediest) && - ( - // - ( - // - mConditions.isXTDSignalUnderBear - // - || - // - mConditions.isXTDBullCrossedUnderBear - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHHHIncreased && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalCrossedUnderBear) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalCrossedUnderBear && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMANeutural && - mConditions.isXLHHHIncreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ( - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMALCPeak) - // - ) - // - ) - // - || - // - (mConditions.isXLHHHDecreased && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHSameHHs && - mConditions.isXTDSignalCrossedUnderBear) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHLHSameHHs) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - ((mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXCHMASCOverMax && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCTrendsUp && - mConditions.isXTDBullUnderBear && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTDSignalUnderBear && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // PriceInSignalRange ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) && - ( - // - mConditions.isXTDBullUnderBear - // - || - // - mConditions.isXTDBullCrossedUnderBear - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXLHPriceCrossedUnderSignal) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXLHPriceCrossedUnderSignal) - // - || - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDSignalCrossedUnderBear) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - mConditions.isXCHMALCVale - // - || - // - mConditions.isXTSCurrentUnderMediest - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsDown) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - (mConditions.isXCHMASCUnderMax || - mConditions.isXCHMASCCrossedUnderMax)) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXCHMASCFastCrossedOverSlow && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTDSignalUnderBear && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMANeutural && - mConditions.isXFIUnderZero && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMAMCTrendsUp) && - ( - // - (mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDBullCrossedUnderBear) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXLHHHDecreased && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXTMBearish && - mConditions.isXTMStartBearish && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXAMAVale && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXTDSignalCrossedUnderBear) - // - || - // - (mConditions.isXAMABearish && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentCrossedUnderMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBullish && - mConditions.isXLHHHDecreased && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXAMANeutural && - mConditions.isXTMStartBullish && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXTDSignalUnderBear) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMAMCTrendsUp) && - ( - // - (mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXFICrossedUnderZero && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDSignalCrossedUnderBear && - 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) && - // - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTDBullUnderBear) - // - || - // - (mConditions.isXTDBullUnderBear && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTMStartBullish && - mConditions.isXCHMALCTrendsDown && - mConditions.isXFICrossedUnderZero && - mConditions.isXCHMALCFastOverSlow) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCTrendsUp && - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) - // - || - // - (mConditions.isXTMStartBullish && - mConditions.isXTDBullUnderBear && - mConditions.isXAMAStartBullish && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXFICrossedUnderZero && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown) && - ( - // - mConditions.isXTSCurrentUnderMediest - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXCHLHSCMCHHSame) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTDBullUnderBear) - // - || - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCFastUnderSlow) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) && - ( - // - mConditions.isXLHHHDecreased - // - || - // - mConditions.isXFICrossedOverZero - // - || - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXCHMASCOverMax && - mConditions.isXTDSignalUnderBear) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTMVale && - mConditions.isXAMAVale) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - || - // - ((mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMASCUnderMax && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest - // - ) - // - ) - // - || - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXAMAVale && - mConditions.isXAMABearish && - mConditions.isXTMEndBearish) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXCHMASCTrendsUp && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHHHDecreased && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - mConditions.isXTDSignalCrossedUnderBear - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXFICrossedUnderZero) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXCHMAMCPeak && - mConditions.isXAMANeutural && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - (((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) || - (mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish)) && - ( - // - mConditions.isXTSCurrentUnderMediest - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsUp && - mConditions.isXCHMASCCrossedOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - mConditions.isXRSICrossedOverLongExit - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCPeak && - mConditions.isXFIUnderZero && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXFICrossedUnderZero) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCPeak && - mConditions.isXLHLLIncreased && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXFICrossedUnderZero) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCCrossedOverMax) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTMEndBullish && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCPeak && - mConditions.isXTMEndBearish && - mConditions.isXLHHHIncreased && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTMEndBullish && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXFICrossedUnderZero && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Long ... - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) && - ( - // - mConditions.isXTDBullUnderBear - // - || - // - mConditions.isXTDBullCrossedUnderBear - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - 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 ... - // - // XTSFI Long ... - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest) && - ( - // - mConditions.isXTDBullUnderBear - // - || - // - mConditions.isXTDBullCrossedUnderBear - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCFastUnderSlow && - mConditions.isXTSCurrentUnderMediest) - // - || - // - ((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) - // - ) - // - ) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXCHMAMCFastCrossedOverSlow && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - // 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 ... - - // - // Common Conditions ... - bool XTSFIHasShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - double tsValues[] = { - mConditions.tsCurrents[1], - mConditions.tsNearests[1], - mConditions.tsMediests[1], - mConditions.tsFarests[1], - }; - - // - double tsMax = GetMax(tsValues); - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - tsMax == mConditions.tsFarests[1] && - (mConditions.isXTSCurrentUnderFarest || - mConditions.isXTSCurrentCrossedUnderFarest) && - (mConditions.tsCurrents[1] > mConditions.tsNearests[1] || - mConditions.tsCurrents[1] > mConditions.tsMediests[1]) && - !(mConditions.isXTSCurrentOverNearest || - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForShort(mConditions) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XTSFIHasSpecifiedShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XTSFIHasShortSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame) && - ( - // - mConditions.isXCHMASCTrendsDown - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBearish && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - (((mConditions.isXTMVale || - mConditions.isXTMNeutural) && - mConditions.isXAMANeutural) && - (mConditions.isXFIOverZero || - mConditions.isXFICrossedOverZero) && - mConditions.isXTSCurrentOverMediest) - // - || - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXFIOverZero && - mConditions.isXTDBullOverBear) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXFIOverZero) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame) - // - || - // - (mConditions.isXTDBearishVale && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXFIOverZero && - mConditions.isXTDBullOverBear) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXTMStartBullish) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDSignalOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXFIOverZero && - mConditions.isXTDBullOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMALCPeak && - (mConditions.isXTMNeutural || - mConditions.isXTMEndBullish) && - (mConditions.isXAMANeutural || - mConditions.isXAMAEndBullish) && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXCHMALCPeak && - mConditions.isXTDBullOverBear && - (mConditions.isXFIOverZero || - mConditions.isXFICrossedOverZero)) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXAMANeutural && - mConditions.isXFIOverZero && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverMediest) && - ( - // - mConditions.isXTMNeutural - // - || - // - (mConditions.isXTMBullish && - mConditions.isXLHLLDecreased) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - (mConditions.isXTMBullish || - mConditions.isXTMStartBullish) && - mConditions.isXAMABullish && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDBullCrossedOverBear) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXFICrossedOverZero && - mConditions.isXTDBullCrossedOverBear) - // - || - // - (mConditions.isXFIOverZero && - mConditions.isXCHMALCPeak && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXFIOverZero && - mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXTMStartBearish && - mConditions.isXTDBullUnderBear && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTDSignalUnderBear) - // - || - // - ((mConditions.isXTMBullish || - mConditions.isXTMStartBullish) && - (mConditions.isXAMABullish || - mConditions.isXAMAStartBullish) && - (mConditions.isXFIOverZero || - mConditions.isXFICrossedOverZero) && - mConditions.isXCHLHSameLLs) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCTrendsUp) - // - || - // - (mConditions.isXCHLHSameLLs && - mConditions.isXTDBearishVale && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentCrossedUnderFarest) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentOverMediest) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest) && - ( - // - mConditions.isXTSCurrentUnderNearest - // - || - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCTrendsUp) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXLHHHDecreased && - mConditions.isXLHLLDecreased && - mConditions.isXTSCurrentOverMediest) - // - || - // - ((mConditions.isXFIOverZero && - mConditions.isXTSCurrentOverMediest) && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTDBullOverBear) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish && - mConditions.isXCHLHSCMCLLSame) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMALCVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - mConditions.isXOBDSwingLow - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTDBullCrossedUnderBear && - mConditions.isXTSCurrentCrossedOverMediest) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - mConditions.isXCHMALCPeak - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTSCurrentCrossedOverMediest) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXTMNeutural && - mConditions.isXFIOverZero && - mConditions.isXTSCurrentCrossedOverMediest) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXTMBearish && - mConditions.isXCHMAMCVale && - mConditions.isXCHLHMCLCLLSame) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXFIOverZero && - mConditions.isXLHHHIncreased && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXFICrossedOverZero) - // - || - // - (mConditions.isXAMABearish && - mConditions.isXCHMAMCVale && - mConditions.isXCHLHMCLCLLSame && - (mConditions.isXTMNeutural || - mConditions.isXTMEndBearish)) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXTMStartBearish && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentUnderFarest) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXTMNeutural && - mConditions.isXCHMAMCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXFICrossedUnderZero && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - ((mConditions.isXAMAVale && - mConditions.isXTMNeutural && - mConditions.isXCHMALCPeak && - mConditions.isXCHMAMCVale) && - ( - // - mConditions.isXLHPriceCrossedUnderSignal - // - || - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXFICrossedUnderZero && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (((mConditions.isXTMBullish || - mConditions.isXTMNeutural || - mConditions.isXTMStartBullish) && - mConditions.isXTSCurrentOverMediest) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - (mConditions.isXTMStartBullish || - mConditions.isXTMEndBullish)) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXAMAStartBearish) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXFIOverZero && - mConditions.isXTMEndBearish && - mConditions.isXFICrossedOverZero) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentOverMediest) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXCHLHSCMCLLSame) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMAStartBearish) && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXTDBullOverBear) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentOverMediest) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXLHHHDecreased) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXCHMASCUnderMax && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentOverMediest) && - ( - // - mConditions.isXLHHHDecreased - // - || - // - mConditions.isXTSCurrentCrossedOverMediest - // - || - // - (mConditions.isXTMVale && - mConditions.isXTMNeutural && - mConditions.isXAMAVale && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMALCTrendsDown) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXFIOverZero && - mConditions.isXTMEndBearish && - mConditions.isXTDBullOverBear) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - mConditions.isXCHLHMCLCLLSame - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentCrossedOverMediest) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDSignalUnderBear) && - ( - // - mConditions.isXTDBullCrossedUnderBear - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXLHHHIncreased && - mConditions.isXTDBullUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverMediest) && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXCHMASCTrendsUp) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXLHHHIncreased && - mConditions.isXTMStartBearish && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - mConditions.isXCHLHSameLLs - // - || - // - (mConditions.isXAMAVale && - mConditions.isXTMNeutural && - mConditions.isXFIOverZero && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXCHLHSCMCLLSame && - ( - // - (mConditions.isXCHLHMCLCHHSame && - ( - // - (mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXTMStartBearish) - // - || - // - ((mConditions.isXTMNeutural || - mConditions.isXTMEndBearish) && - (mConditions.isXAMANeutural || - mConditions.isXAMAEndBearish)) - // - || - // - (mConditions.isXTMVale && - mConditions.isXCHMAMCVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest) - // - ) - // - ) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXFIOverZero && - mConditions.isXCHMAMCVale && - mConditions.isXTMEndBearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXFIOverZero && - mConditions.isXCHMAMCVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXCHMAMCVale && - mConditions.isXLHHHDecreased && - mConditions.isXFICrossedUnderZero && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXAMAVale && - mConditions.isXCHMALCPeak) && - ( - // - mConditions.isXTMNeutural - // - || - // - (mConditions.isXTMVale && - mConditions.isXTMEndBearish && - mConditions.isXLHLLDecreased) - // - ) - // - ) - // - || - // - (mConditions.isXTMVale && - mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXCHMAMCVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMax && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentOverMediest) && - ( - // - mConditions.isXCHMAMCTrendsDown - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - mConditions.isXTMStartBearish && - mConditions.isXTDBullOverBear && - mConditions.isXAMAStartBearish && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentOverMediest) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXTMBullish) - // - || - // - (mConditions.isXAMAVale && - (mConditions.isXTMNeutural || - mConditions.isXTMEndBearish)) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check Conditions if Price is Over Signal ... - ( - // - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // Next Step is to Check LL and HH Same Style ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentOverMediest) && - ( - // - (mConditions.isXCHLHMCLCLLSame && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - (mConditions.isXTDBullUnderBear && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentOverMediest) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXFIOverZero && - mConditions.isXTSCurrentOverMediest) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXTDBullOverBear) - // - || - // - (mConditions.isXAMABullish && - mConditions.isXTDBullCrossedOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXLHLLIncreased && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCTrendsUp) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsUp) - // - || - // - (mConditions.isXCHMAMCTrendsUp && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXCHMALCPeak) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHLHSCMCLLSame) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXLHHHDecreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXTMBullish || - mConditions.isXTMStartBullish) - // - && - // - (mConditions.isXAMABullish || - mConditions.isXAMAStartBullish)) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsUp) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXLHLLIncreased && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXLHHHIncreased && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCTrendsUp) - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXTMStartBearish && - mConditions.isXTDBullOverBear) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXFIOverZero && - mConditions.isXTDBullOverBear) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCTrendsUp) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsUp) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentOverMediest) - // - || - // - ((mConditions.isXTMBullish || - mConditions.isXTMStartBullish) && - (mConditions.isXAMABullish || - mConditions.isXAMAStartBullish) && - (mConditions.isXTSCurrentOverMediest || - mConditions.isXTSCurrentCrossedOverMediest)) - // - )) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTSCurrentOverMediest || - mConditions.isXTSCurrentCrossedOverMediest) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMAMCVale && - mConditions.isXLHHHDecreased && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXTMNeutural && - mConditions.isXFIOverZero && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverMediest) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTMStartBearish) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHLHSameLLs) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCTrendsUp && - (mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow)) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // Exceptions: - // there some commonly Exceptions which makes our choice incorrect, - // here we are combined knownly Exceptions ... - !( - // - // XTSFI Short ... - // Resolve Stop Outs ... - ( - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMASCFastCrossedOverSlow && - ( - // - (mConditions.isXAMANeutural && - ( - // - (mConditions.isXTMVale && - mConditions.isXCHMASCVale && - mConditions.isXTMNeutural) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXCHMAMCVale && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXFIOverZero && - mConditions.isXTDBearishVale && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXTSCurrentCrossedUnderFarest && - mConditions.isXTSCurrentCrossedUnderNearest) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXLHHHDecreased) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTMVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMAMCVale) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXLHHHIncreased && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // All Neutural ... - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCFastCrossedUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Current Over Mediest ... - (mConditions.isXTSCurrentOverMediest && - ( - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXTMStartBearish && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXLHLLDecreased && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTMBullish && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXAMABullish && - ( - // - mConditions.isXTDBullOverBear - // - || - // - mConditions.isXTDBullCrossedOverBear - // - ) - // - ) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXTDBullCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXCHMAMCVale && - mConditions.isXFICrossedOverZero) && - ( - // - mConditions.isXCHMASCUnderMin - // - || - // - (mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax && - mConditions.isXCHMALCTrendsDown) - // - || - // - (mConditions.isXTSCurrentCrossedOverMediest && - mConditions.isXAMAVale && - mConditions.isXCHMALCPeak) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXCHMAMCVale) && - ( - // - (mConditions.isXAMAStartBearish && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCTrendsDown) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentCrossedOverMediest) - // - || - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentCrossedUnderFarest) - // - || - // - (mConditions.isXCHMASCOverMin && - mConditions.isXCHMASCUnderMax && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXLHLLIncreased && - mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish && - mConditions.isXCHMALCTrendsDown) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXFIUnderZero && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXFICrossedUnderZero && - mConditions.isXTSCurrentUnderFarest) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameLLs) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXCHMASCOverMax && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame) - // - || - // - mConditions.isXTSCurrentCrossedOverMediest - // - ) - // - ) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMALCVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHLHMCLCLLSame && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXLHPriceCrossedOverSignal && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMANeutural) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXAMABearish && - mConditions.isXTMStartBearish && - mConditions.isXCHMALCTrendsDown) - // - || - // - (mConditions.isXTSCurrentCrossedUnderNearest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMASCTrendsUp && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - ((mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXLHHHDecreased && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - || - // - ((mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXCHMASCUnderMin && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHLHSCMCLLSame) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameLLs) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHLHSCMCLLSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXCHMALCPeak) - // - || - // - (mConditions.isXCHMASCUnderMin && - ( - // - mConditions.isXAMAVale - // - || - // - (mConditions.isXCHLHSameLLs && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - ((mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame) && - ( - // - mConditions.isXLHLowAttachedLL - // - || - // - mConditions.isXTSCurrentCrossedUnderNearest - // - || - // - (!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMAMCVale && - mConditions.isXCHLHSameLLs) - // - || - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXLHLowAttachedLL) - // - || - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - // XTSFI Short ... - // Resolve Guard Attacks ... - || - // - ( - // - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXAMANeutural && - ( - // - mConditions.isXTMBullish - // - || - // - mConditions.isXTMStartBullish - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDBullOverBear) - // - || - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - mConditions.isXTDBullCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXAMANeutural && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXCHMASCUnderMin && - mConditions.isXFICrossedUnderZero) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXTDBearishVale && - mConditions.isXCHMASCUnderMin) && - ( - // - mConditions.isXTMBullish - // - || - // - mConditions.isXTMStartBullish - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak) && - ( - // - (mConditions.isXCHMALCFastOverSlow && - ( - // - (mConditions.isXAMAVale && - ( - // - mConditions.isXTMNeutural - // - || - // - mConditions.isXTMEndBullish - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMAStartBearish) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXLHLLIncreased) - // - || - // - (mConditions.isXLHHHDecreased && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTMStartBearish && - ( - // - mConditions.isXCHLHMCLCHHSame - // - || - // - (!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXTMNeutural && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - (mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXLHHHDecreased) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - mConditions.isXCHLHSCMCLLSame - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXAMAEndBearish && - mConditions.isXFICrossedUnderZero) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXFIUnderZero && - mConditions.isXTSCurrentUnderFarest) - // - || - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXFIUnderZero && - mConditions.isXTSCurrentUnderFarest) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - mConditions.isXCHLHSameLLs - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXFICrossedUnderZero && - mConditions.isXTDBullCrossedUnderBear) && - ( - // - mConditions.isXCHMAMCVale - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXLHPriceCrossedUnderSignal && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // XTD Bearish ... - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - mConditions.isXTMNeutural - // - || - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXTMStartBearish && - ( - // - mConditions.isXAMANeutural - // - || - // - mConditions.isXAMAStartBearish - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalOverBear && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXCHMALCPeak && - mConditions.isXCHMALCFastOverSlow) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTDSignalOverBear && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame) && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMANeutural) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXLHPriceCrossedOverSignal && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXFIOverZero && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXAMABullish && - mConditions.isXTMNeutural) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXAMABullish && - mConditions.isXTMNeutural) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXFIOverZero) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) - // - || - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXCHMASCOverMax && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - mConditions.isXCHMALCVale - // - ) - // - ) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCOverMax) && - ( - // - ((mConditions.isXAMAVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXAMANeutural && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) && - ( - // - mConditions.isXTMStartBearish - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTMNeutural && - ( - // - (mConditions.isXAMANeutural && - ( - // - mConditions.isXCHMAMCVale - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) && - ( - // - mConditions.isXTMStartBearish - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXAMABearish && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXLHHHIncreased && - mConditions.isXTMStartBearish) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMEndBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXFIOverZero && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame) && - ( - // - (mConditions.isXAMANeutural && - ( - // - mConditions.isXTMBullish - // - || - // - mConditions.isXTMStartBullish - // - ) - // - ) - // - || - // - (mConditions.isXAMAVale && - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - (mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - mConditions.isXTMVale - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXCHMASCUnderMin && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXFIOverZero && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) && - ( - // - ((mConditions.isXCHMASCOverMax && - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXLHPriceCrossedOverSignal && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXCHMALCVale && - ( - // - mConditions.isXAMANeutural - // - || - // - mConditions.isXAMAEndBearish - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTMVale && - mConditions.isXTMEndBearish && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // All Other Wises ... - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - (mConditions.isXTDSignalOverBear && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDSignalCrossedOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - || - // - (mConditions.isXFIOverZero && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXCHMASCUnderMin) && - ( - // - mConditions.isXTDSignalOverBear - // - || - // - mConditions.isXTDSignalCrossedOverBear - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMASCUnderMin && - ( - // - (mConditions.isXAMAVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCCrossedUnderMin) - // - || - // - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXCHLHSCMCLLSame && - ( - // - (mConditions.isXAMAVale && - ( - // - mConditions.isXTMVale - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXLHPriceCrossedUnderSignal && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXTMVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXLHHHDecreased && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXLHHHDecreased && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXCHMALCVale) - // - || - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Other Wises ... - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - mConditions.isXRSICrossedOverLongEntry - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMASCTrendsUp && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXLHLLIncreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - || - // - ((mConditions.isXLHHHIncreased && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXLHPriceCrossedOverSignal && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - mConditions.isXCHLHSameLLs - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame) && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXCHLHSCMCLLSame && - ( - // - mConditions.isXAMAVale - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXLHLLIncreased && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XTSFI Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - mConditions.isXTSCurrentCrossedOverMediest - // - || - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMAMCFastCrossedOverSlow) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTMEndBullish && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXAMAStartBearish && - mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow && - mConditions.isXTSCurrentCrossedUnderFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMANeutural && - mConditions.isXCHMAMCVale) && - ( - // - mConditions.isXCHLHSCMCLLSame - // - || - // - mConditions.isXCHMASCUnderMin - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - || - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMASCUnderMin && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - || - // - (mConditions.isXCHMALCVale && - ( - // - ((mConditions.isXTMVale && - mConditions.isXAMAVale) && - ( - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXFIOverZero && - mConditions.isXAMANeutural && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXAMAStartBearish && - mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow && - mConditions.isXTSCurrentCrossedUnderFarest) - // - ) - // - ) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXCHMASCCrossedUnderMax && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMANeutural) && - ( - // - mConditions.isXTDBullOverBear - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTMStartBullish && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMASCFastOverSlow && - mConditions.isXCHMAMCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXAMAVale && - mConditions.isXCHMASCUnderMin) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - mConditions.isXTDBullOverBear - // - || - // - mConditions.isXCHLHSCMCLLSame - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXCHMASCUnderMin && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXRSICrossedUnderShortExit) - // - || - // - (mConditions.isXCHMALCFastOverSlow && - ( - // - (mConditions.isXCHMALCTrendsDown && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTMVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMAMCFastOverSlow) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXTMStartBearish && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMASCFastOverSlow) - // - || - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXCHMASCFastCrossedOverSlow && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCFastOverSlow && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXAMAVale && - mConditions.isXTMNeutural && - mConditions.isXTMEndBearish && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXAMAVale && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - mConditions.isXCHMALCPeak - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXTDBullUnderBear && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMALCFastOverSlow && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCPeak && - mConditions.isXFICrossedOverZero && - mConditions.isXTDBullCrossedOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXTMVale && - mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCFastOverSlow && - ( - // - (mConditions.isXTMVale && - mConditions.isXCHMASCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXAMAVale && - mConditions.isXTMNeutural && - mConditions.isXCHMAMCVale && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - || - // - ((mConditions.isXTMVale && - mConditions.isXAMAVale) && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - mConditions.isXCHMASCUnderMin - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameLLs && - mConditions.isXLHHHDecreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTMNeutural && - ( - // - (mConditions.isXAMAVale && - mConditions.isXCHMAMCVale) - // - || - // - (mConditions.isXFIOverZero && - mConditions.isXCHMALCPeak && - mConditions.isXTDBullOverBear && - mConditions.isXFICrossedOverZero) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) && - ( - // - mConditions.isXTSCurrentCrossedOverMediest - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHMASCFastOverSlow) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCFastOverSlow && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCFastOverSlow && - ( - // - (mConditions.isXTMBullish && - mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXTDBearishVale && - mConditions.isXTDBullOverBear && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCTrendsUp) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCFastOverSlow && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // PriceUnderSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameLLs && - mConditions.isXLHHHDecreased) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameLLs && - mConditions.isXTDSignalVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXLHHHDecreased && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBearish && - mConditions.isXCHMALCFastOverSlow) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - || - // - (mConditions.isXCHMAMCFastOverSlow && - ( - // - (mConditions.isXCHMAMCTrendsUp && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) - // - || - // - (mConditions.isXTMEndBullish && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHLHMCLCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMALCVale && - mConditions.isXTDSignalVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXCHMALCFastOverSlow && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXAMABullish && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsUp) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXLHLLDecreased && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXTMNeutural && - ( - // - mConditions.isXAMANeutural - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXLHPriceCrossedOverSignal && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - mConditions.isXLHPriceCrossedOverSignal - // - || - // - (mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XTSFI Short ... - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXTMEndBullish && - mConditions.isXTDBearishVale) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXLHHHIncreased && - mConditions.isXLHLLIncreased && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame) - // - || - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMALCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDBullOverBear && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXTMStartBearish && - mConditions.isXTDBullUnderBear && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - ((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) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame && - 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) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXTMNeutural && - mConditions.isXCHMAMCVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) - // - || - // - (mConditions.isXTMVale && - mConditions.isXCHMAMCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - || - // - // 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.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXLHHHDecreased && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentOverMediest) - // - || - // - ((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 ... - - // - // Common Conditions ... - bool XOBDLHHasLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - X5MarketConditions mConditions2; - GetMarketConditions( - mConditions, - 2 // - ); - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - mConditions2.isXOBDSwingLow && - mConditions2.isXLHLowAttachedLL && - mConditions.lhLls[1] >= mConditions.lhLls[2] - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForLong( - mConditions, - true, // XCHMA Min - true, // XCHMA Max - false, // XCHMA Cycles - false, // XCHMA Peaks - false, // XCHMA Trend Powers - false, // XOBD - false // XTS - ) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XOBDLHHasSpecifiedLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XOBDLHHasLongSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMALCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentUnderFarest) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTMEndBearish && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame) - // - || - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) - // - || - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame) - // - || - // - (mConditions.isXTMVale && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXAMAStartBearish) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame) - // - || - // - ((mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHLHSameLLs) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXLHHHDecreased) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) - // - || - // - ((mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame) && - ( - // - mConditions.isXTSCurrentMax - // - || - // - mConditions.isXLHLowAttachedLL - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentUnderFarest) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHMALCPeak && - mConditions.isXTMEndBearish && - mConditions.isXCHLHSCMCLLSame) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXTMNeutural && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCLLSame) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMStartBearish && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXAMAStartBearish) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXTSAllSame && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTMStartBearish && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXCHLHSameLLs) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXTMStartBullish && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check Conditions if Price is Over Signal ... - ( - // - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // Next Step is to Check LL and HH Same Style ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - false) - // - ) - // - || - // - // XOBDLH 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 ... - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - // - // - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMAMCFastUnderSlow) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXCHMASCTrendsUp && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // XOBDLH Long ... - // PriceUnderSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXTMVale && - mConditions.isXAMAVale) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXLHLowAttachedLL && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - - // - // Common Conditions ... - bool XOBDLHHasShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - X5MarketConditions mConditions2; - GetMarketConditions( - mConditions, - 2 // - ); - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - mConditions2.isXOBDSwingHigh && - mConditions2.isXLHHighAttachedHH && - mConditions.lhHhs[1] <= mConditions.lhHhs[2] - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForShort( - mConditions, - true, // XCHMA Min - true, // XCHMA Max - false, // XCHMA Cycles - false, // XCHMA Peaks - false, // XCHMA Trend Powers - false, // XOBD - false // XTS - ) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XOBDLHHasSpecifiedShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XOBDLHHasShortSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCCrossedUnderMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCPeak && - mConditions.isXCHMALCTrendsUp) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMax && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTDBullOverBear) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - mConditions.isXTDSignalOverBear) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXTMEndBullish && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXTMEndBullish) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - || - // - (mConditions.isXFIOverZero && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverMediest && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - || - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullCrossedOverBear) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsUp) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak) - // - ) - // - ) - // - ) - // - ) - // - || - // - (((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - || - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) && - ( - // - (mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsUp) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsUp) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXTDBullOverBear && - mConditions.isXAMAStartBullish && - mConditions.isXTDSignalOverBear) - // - ) - // - ) - // - || - // - (((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXFIOverZero && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsUp) - // - ) - // - ) - // - || - // - (((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXFIOverZero && - mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - 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 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMALCTrendsUp && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMASCFastOverSlow && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXCHMALCFastOverSlow) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMALCTrendsUp) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMASCFastOverSlow && - mConditions.isXCHMAMCFastOverSlow) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - 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 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - - // - // Common Conditions ... - bool XCHMACCHasLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - mConditions.chmaScFasts[1] > mConditions.chmaScSlows[1] && - mConditions.chmaMcFasts[1] > mConditions.chmaMcSlows[1] && - mConditions.chmaLcFasts[1] > mConditions.chmaLcSlows[1] && - // - mConditions.chmaScFasts[2] > mConditions.chmaScSlows[2] && - mConditions.chmaMcFasts[2] > mConditions.chmaMcSlows[2] && - mConditions.chmaLcFasts[2] > mConditions.chmaLcSlows[2] && - // - !( - // - mConditions.chmaScFasts[3] > mConditions.chmaScSlows[3] && - mConditions.chmaMcFasts[3] > mConditions.chmaMcSlows[3] && - mConditions.chmaLcFasts[3] > mConditions.chmaLcSlows[3] - // - ) - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForLong(mConditions) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XCHMACCHasSpecifiedLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XCHMACCHasLongSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCTrendsDown && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - (mConditions.isXTSCurrentOverFarest || - mConditions.isXTDSignalCrossedUnderBear)) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMANeutural && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTMStartBullish && - mConditions.isXFICrossedUnderZero) - // - || - // - ( - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXAMAStartBullish) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXLHLLDecreased) - // - ) - // - ) - // - ) - // - ) - // - )) - // - || - // - (((mConditions.isXTMNeutural && - mConditions.isXTMEndBullish && - mConditions.isXFICrossedUnderZero) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear)) - // - && - // - (mConditions.isXCHMALCPeak && - ( - // - mConditions.isXCHMALCTrendsDown - // - || - // - (mConditions.isXCHLHMCLCHHSame && - (mConditions.isXTDSignalUnderBear || - mConditions.isXTDSignalCrossedUnderBear)) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCTrendsDown && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCTrendsDown && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXAMAVale && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMAStartBearish && - mConditions.isXFICrossedUnderZero) - // - || - // - ((mConditions.isXAMANeutural || - mConditions.isXAMAEndBearish) && - mConditions.isXTMStartBullish && - mConditions.isXFICrossedOverZero) - // - || - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMax && - mConditions.isXTMStartBullish && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDBullUnderBear) - // - ) - // - ) - // - || - // - ((mConditions.isXAMABearish && - (mConditions.isXTMNeutural || - mConditions.isXTMBearish)) && - mConditions.isXTSCurrentUnderMediest && - (mConditions.isXTDBullCrossedUnderBear || - (mConditions.isXTDBullUnderBear && - mConditions.isXFICrossedUnderZero))) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCTrendsDown && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTSCurrentMax && - ( - // - (mConditions.isXAMABearish && - mConditions.isXTDBullCrossedOverBear) - // - || - // - (mConditions.isXTMStartBullish && - ( - // - ( - // - mConditions.isXAMAStartBullish - // - || - // - (mConditions.isXAMAEndBearish && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - (mConditions.isXLHLLDecreased && - mConditions.isXTMStartBullish && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMEndBullish && - mConditions.isXAMAEndBullish) - // - || - // - (mConditions.isXTSCurrentMax && - (mConditions.isXTMBullish || - mConditions.isXTMStartBullish) && - (mConditions.isXAMABullish || - mConditions.isXAMAStartBullish) && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTDSignalUnderBear) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - mConditions.isXTDBearishVale - // - || - // - mConditions.isXRSICrossedOverLongExit - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHLHMCLCLLSame) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCTrendsDown && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame) - // - || - // - (mConditions.isXCHMASCVale && - mConditions.isXFIUnderZero && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsDown)) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - ( - // - mConditions.isXCHMALCTrendsDown - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ( - mConditions.isXTDSignalUnderBear && - ( - // - mConditions.isXTSAllSame - // - || - // - ((mConditions.isXTSCurrentUnderNearest || - mConditions.isXTSCurrentCrossedUnderNearest)) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMALCTrendsUp && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXLHPriceCrossedOverSignal && - (mConditions.isXCHMAMCTrendsDown && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow))) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXCHMAMCTrendsDown) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMALCPeak && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) && - ( - // - (mConditions.isXCHMALCTrendsDown && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHLHSameHHs && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderNearest) - // - || - // - ( - (mConditions.isXAMABullish && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBullish && - mConditions.isXTDSignalUnderBear) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXTSCurrentMax) && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXTDBullCrossedOverBear && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ( - (mConditions.isXCHMAMCTrendsDown && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish) - // - || - (mConditions.isXLHLLDecreased && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXCHMAMCPeak && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - )) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHLHSameHHs && - (mConditions.isXTSCurrentUnderNearest || - mConditions.isXTSCurrentCrossedUnderNearest) && - (mConditions.isXTSCurrentUnderMediest || - mConditions.isXTSCurrentCrossedUnderMediest)) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXTMStartBullish && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCTrendsDown && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXTMEndBullish && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCTrendsDown && - ( - // - (((mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentMax) && - ( - // - mConditions.isXCHLHMCLCHHSame - // - || - // - (mConditions.isXTDSignalUnderBear && - mConditions.isXCHMALCPeak) - // - || - // - (mConditions.isXTDSignalUnderBear && - mConditions.isXFICrossedOverZero) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHMAMCPeak && - mConditions.isXTMEndBullish && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentUnderNearest) - // - ) - // - ) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCTrendsDown && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHLHSCMCHHSame) && - ( - // - mConditions.isXTSCurrentUnderNearest - // - || - // - (mConditions.isXLHLLIncreased && - mConditions.isXTDBullUnderBear && - mConditions.isXLHHighAttachedHH && - mConditions.isXTDSignalUnderBear && - mConditions.isXFICrossedUnderZero) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMALCTrendsDown && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish && - (mConditions.isXTSCurrentMin || - mConditions.isXTSCurrentMax)) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXLHLLIncreased && - mConditions.isXCHLHSCMCHHSame && - 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // Exceptions: - // there some commonly Exceptions which makes our choice incorrect, - // here we are combined knownly Exceptions ... - !( - // - // XCHMACC Long ... - // Resolve Stop Outs ... - ( - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXLHLLDecreased) - // - || - // - ((mConditions.isXCHMASCVale && - mConditions.isXTMBearish) && - ( - // - mConditions.isXAMABearish - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentCrossedUnderNearest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXCHLHMCLCHHSame) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXTSCurrentCrossedUnderNearest && - ( - // - mConditions.isXTDSignalCrossedOverBear - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXAMAEndBullish && - !mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentCrossedUnderFarest) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // All Bullish ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXLHLLIncreased && - mConditions.isXTMStartBullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame) && - ( - // - mConditions.isXTSCurrentUnderFarest - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - !mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXTSCurrentCrossedUnderNearest && - ( - // - (mConditions.isXTMStartBullish && - mConditions.isXTDBullCrossedOverBear && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // All Bullish ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXLHLLDecreased) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDBearishVale && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // All Bullish ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - || - // - ( - // - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMin && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCUnderMax) - // - || - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMASCVale) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame) && - ( - // - mConditions.isXAMAStartBullish - // - || - // - (mConditions.isXLHLLDecreased && - mConditions.isXTDBullCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // All Neutural ... - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMax && - mConditions.isXLHLLDecreased && - mConditions.isXTMStartBullish) - // - || - // - ((mConditions.isXAMANeutural && - mConditions.isXLHLLDecreased && - mConditions.isXCHMASCOverMin && - mConditions.isXTMStartBullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentUnderFarest) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentCrossedOverFarest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentCrossedOverFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame) && - ( - // - mConditions.isXTMStartBullish - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXTSCurrentCrossedOverFarest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame) - // - || - // - (mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCLLSame) && - ( - // - mConditions.isXTSCurrentMax - // - || - // - mConditions.isXTSCurrentUnderFarest - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - mConditions.isXRSICrossedOverLongExit - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCCrossedOverMax && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // All Bullish ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXAMAStartBullish && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXLHHHDecreased && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // All Bullish ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXAMANeutural && - ( - // - mConditions.isXTMNeutural - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXTMStartBullish) - // - ) - // - ) - // - || - // - (mConditions.isXFIUnderZero && - mConditions.isXFICrossedUnderZero) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDBearishVale && - mConditions.isXLHLLDecreased) - // - ) - // - ) - // - || - // - (mConditions.isXTDBearishVale && - ( - // - (mConditions.isXTSAllSame && - mConditions.isXCHMALCPeak && - mConditions.isXLHLLDecreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXLHHHDecreased && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXLHHHDecreased && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXTDBearishVale && - mConditions.isXLHPriceCrossedUnderSignal) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCPeak && - mConditions.isXLHHHDecreased && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - mConditions.isXRSICrossedOverLongExit - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax) && - ( - // - (mConditions.isXLHLLIncreased && - mConditions.isXCHMASCOverMax) - // - || - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - mConditions.isXLHHighAttachedHH && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXLHHHDecreased && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXLHPriceCrossedOverSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXLHHHIncreased) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTDSignalOverBear && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXLHHighAttachedHH && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTDSignalCrossedOverBear) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXLHHighAttachedHH) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // All Bullish ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTDBullUnderBear && - ( - // - mConditions.isXRSICrossedOverLongExit - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXCHLHSCMCHHSame && - ( - // - mConditions.isXTDBullCrossedOverBear - // - || - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCCrossedOverMax) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXTSCurrentCrossedUnderNearest && - ( - // - (mConditions.isXCHMASCOverMax && - ( - // - mConditions.isXRSICrossedOverLongExit - // - || - // - (mConditions.isXCHMALCPeak && - ( - // - mConditions.isXCHLHSameHHs - // - || - // - mConditions.isXLHLLIncreased - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish && - mConditions.isXLHHighAttachedHH && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXTSCurrentUnderFarest && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXTSCurrentMax && - ( - // - mConditions.isXTDSignalUnderBear - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXTDSignalCrossedOverBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXTDBullOverBear) && - ( - // - (mConditions.isXAMABullish && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXTMStartBullish && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHMASCCrossedOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // All Bullish ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMASCOverMax && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXTSAllSame && - mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // All Bullish ... - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - mConditions.isXRSICrossedOverLongExit - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - mConditions.isXTSCurrentUnderMediest - // - || - // - mConditions.isXTSCurrentCrossedUnderNearest - // - ) - // - ) - // - || - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXTMStartBullish && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow ... - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - // - (!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDBullCrossedUnderBear) - // - || - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDSignalUnderBear) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest) - // - || - // - (mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXCHMASCOverMax && - mConditions.isXTSCurrentUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXTDSignalUnderBear && - mConditions.isXRSICrossedOverLongExit) - // - || - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXTDSignalUnderBear && - mConditions.isXRSICrossedOverLongExit) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXLHHighAttachedHH && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXTDBearishVale && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Long ... - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - mConditions.isXRSICrossedOverLongExit - // - || - // - ((mConditions.isXCHMASCFastOverSlow && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXTDBullUnderBear && - 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 ... - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - // XCHMACC Longs ... - // Guard Attacks Resolves ... - || - // - ( - // - (mConditions.isXTSCurrentUnderNearest && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - mConditions.isXTSCurrentCrossedUnderNearest - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentCrossedUnderNearest && - ( - // - (mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXCHMASCCrossedOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderMediest && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - mConditions.isXTMNeutural - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullUnderBear && - ( - // - (mConditions.isXTDSignalUnderBear && - ( - // - (mConditions.isXCHMASCFastOverSlow && - (mConditions.isXCHMASCTrendsDown || - (!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown))) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalUnderBear && - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - (mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - || - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax) && - ( - // - mConditions.isXLHPriceCrossedOverSignal - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTMEndBullish && - mConditions.isXLHHHDecreased && - mConditions.isXCHMASCOverMax) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - ((mConditions.isXCHMASCOverMax && - mConditions.isXCHLHMCLCHHSame) && - ( - // - mConditions.isXCHLHMCLCLLSame - // - || - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHMALCPeak) && - ( - // - mConditions.isXTMStartBullish - // - || - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - || - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullOverBear) && - ( - // - (mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceOverSignal) - // - || - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow && - (mConditions.isXCHMAMCTrendsDown || - (!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown))) && - ( - // - ((mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax) && - ( - // - mConditions.isXLHPriceCrossedOverSignal - // - || - // - ((mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) && - ( - // - (mConditions.isXLHHHDecreased && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceInSignalRange) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXTDBullCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentUnderFarest && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXFICrossedUnderZero) - // - ) - // - ) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXFICrossedUnderZero) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow) && - ( - // - ((mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax) && - ( - // - (mConditions.isXTDBearishVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTMEndBullish && - mConditions.isXLHHHDecreased && - mConditions.isXTDSignalCrossedOverBear) - // - || - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentCrossedOverNearest) && - ( - // - mConditions.isXCHMASCPeak - // - || - // - mConditions.isXCHMALCPeak - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXCHMASCOverMax && - mConditions.isXLHHighAttachedHH) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXLHLLIncreased && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMin && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMALCPeak && - mConditions.isXCHMASCOverMax && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXCHMALCFastOverSlow && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - ((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.isXCHLHSameHHs && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderNearest) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMax && - mConditions.isXTDBullUnderBear && - mConditions.isXLHHighAttachedHH && - mConditions.isXTDSignalUnderBear && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - ((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 ... - - // - // Common Conditions ... - bool XCHMACCHasShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - mConditions.chmaScFasts[1] < mConditions.chmaScSlows[1] && - mConditions.chmaMcFasts[1] < mConditions.chmaMcSlows[1] && - mConditions.chmaLcFasts[1] < mConditions.chmaLcSlows[1] && - // - mConditions.chmaScFasts[2] < mConditions.chmaScSlows[2] && - mConditions.chmaMcFasts[2] < mConditions.chmaMcSlows[2] && - mConditions.chmaLcFasts[2] < mConditions.chmaLcSlows[2] && - // - !( - // - mConditions.chmaScFasts[3] < mConditions.chmaScSlows[3] && - mConditions.chmaMcFasts[3] < mConditions.chmaMcSlows[3] && - mConditions.chmaLcFasts[3] < mConditions.chmaLcSlows[3] - // - ) - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForLong(mConditions) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XCHMACCHasSpecifiedShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XCHMACCHasShortSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXTMStartBullish && - mConditions.isXTDSignalOverBear && - mConditions.isXTSCurrentOverFarest) - // - || - // - ((mConditions.isXFIOverZero && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest) && - ( - // - (mConditions.isXAMAStartBearish && - mConditions.isXFICrossedOverZero) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXAMAStartBullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) && - ( - // - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXLHLLIncreased && - mConditions.isXAMAStartBearish && - mConditions.isXTSCurrentOverNearest) - // - || - // - (((mConditions.isXTMNeutural || - mConditions.isXTMEndBearish) && - (mConditions.isXAMANeutural || - mConditions.isXAMAEndBullish)) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXTSAllSame && - mConditions.isXCHMAMCTrendsDown) - // - ) - // - ) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTSCurrentMin && - mConditions.isXCHMALCTrendsUp && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - ( - // - ((mConditions.isXTMEndBearish || - mConditions.isXTMNeutural) && - (mConditions.isXAMABearish || - mConditions.isXAMANeutural) && - mConditions.isXFIOverZero && - mConditions.isXTDBullOverBear && - mConditions.isXFICrossedOverZero && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXAMANeutural && - mConditions.isXTMStartBearish && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXCHMALCVale && - ( - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXTMStartBearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentOverMediest) - // - || - // - ((mConditions.isXTMNeutural || - mConditions.isXTMEndBearish) && - (mConditions.isXAMANeutural || - mConditions.isXAMAEndBearish) && - mConditions.isXLHHHIncreased && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMABearish && - mConditions.isXTMEndBearish && - mConditions.isXTDBullOverBear) && - ( - // - mConditions.isXCHLHSCMCLLSame - // - || - // - (mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentCrossedOverFarest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTSCurrentMin && - mConditions.isXTDBullOverBear && - mConditions.isXAMAStartBearish && - mConditions.isXTDSignalUnderBear) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - ((mConditions.isXTMStartBearish && - mConditions.isXTDBullOverBear && - mConditions.isXAMAStartBearish) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) && - ( - // - mConditions.isXCHMALCTrendsDown - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTSCurrentMin) && - ( - // - (mConditions.isXFICrossedUnderZero && - mConditions.isXTDBullCrossedUnderBear) - // - || - // - (mConditions.isXCHMALCTrendsUp && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXFICrossedUnderZero && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCTrendsDown && - mConditions.isXTSCurrentOverNearest) - // - || - // - (mConditions.isXCHMALCVale && - (mConditions.isXTSCurrentOverNearest || - mConditions.isXTSCurrentCrossedOverNearest) && - (mConditions.isXTSCurrentOverFarest || - mConditions.isXTSCurrentCrossedOverFarest)) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTSCurrentMin) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMALCTrendsUp) - // - || - // - ((mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXCHMASCVale) - // - || - // - ((mConditions.isXCHLHSameLLs && - mConditions.isXLHHHIncreased && - mConditions.isXLHLowAttachedLL) && - ( - // - mConditions.isXCHMAMCTrendsDown - // - || - // - mConditions.isXCHMASCCrossedUnderMin - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXTDBullCrossedUnderBear) && - ( - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL) - // - || - // - (mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXAMABearish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMEndBearish && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverNearest) - // - || - // - (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 ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMALCVale && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXTSCurrentOverMediest) - // - || - // - (mConditions.isXFIUnderZero && - mConditions.isXTSCurrentMin && - mConditions.isXTDBullUnderBear && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTSCurrentCrossedUnderFarest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXCHLHMCLCLLSame) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish && - mConditions.isXTDBullOverBear) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMax) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMANeutural && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXFIOverZero && - mConditions.isXTMStartBullish && - mConditions.isXTDBullOverBear && - mConditions.isXAMAStartBullish && - mConditions.isXTSCurrentOverNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXTDSignalVale && - mConditions.isXTSCurrentMin && - mConditions.isXTDBullishVale && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMANeutural) - // - ) - // - ) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMANeutural && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCOverMin && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMax && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMax && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXLHHHIncreased && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest) - // - || - // - ((mConditions.isXTMNeutural || - mConditions.isXTMEndBearish) && - (mConditions.isXAMANeutural || - mConditions.isXAMAEndBearish) && - mConditions.isXFIOverZero && - mConditions.isXTDBullOverBear && - mConditions.isXFICrossedOverZero && - mConditions.isXTSCurrentOverNearest) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXFIOverZero && - mConditions.isXTSCurrentMax && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXLHLLIncreased && - mConditions.isXCHMALCTrendsUp && - mConditions.isXAMAStartBearish) - // - || - // - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXTSCurrentMin && - mConditions.isXAMAEndBullish && - mConditions.isXTMStartBearish && - mConditions.isXTDBullOverBear && - mConditions.isXCHMAMCTrendsDown) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXTDBullUnderBear && - mConditions.isXCHMALCTrendsDown && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // Exceptions: - // there some commonly Exceptions which makes our choice incorrect, - // here we are combined knownly Exceptions ... - !( - // - // XCHMACC Short ... - // Resolve Stop Outs ... - ( - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMin && - mConditions.isXLHHHIncreased && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Otherwises ... - (mConditions.isXTDBullOverBear && - ( - // - ((!mConditions.isXCHMALCTrendsUp && - !mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedUnderNearest) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXTSCurrentCrossedOverNearest && - ( - // - (mConditions.isXLHHHDecreased && - mConditions.isXCHMASCUnderMin) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXTMStartBearish) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXLHHHIncreased && - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - mConditions.isXTSCurrentMin - // - || - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentCrossedOverFarest) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalOverBear && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverNearest && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMStartBearish && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - (mConditions.isXRSICrossedUnderShortExit && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXAMABullish && - mConditions.isXTMStartBearish && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCUnderMin) && - ( - // - mConditions.isXTSCurrentMax - // - || - // - mConditions.isXCHMASCCrossedUnderMin - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTSCurrentOverNearest && - ( - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - mConditions.isXTSCurrentCrossedOverNearest - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((!mConditions.isXCHMALCTrendsUp && - !mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLLSameInLength && - mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXFIOverZero && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Under Signal ... - // Other wises ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTSCurrentOverNearest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price In Signal Range ... - // All Neutural ... - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTDBullCrossedUnderBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL && - mConditions.isXLHPriceCrossedUnderSignal && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDSignalCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXRSICrossedUnderShortExit && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Under Signal ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - (mConditions.isXRSICrossedUnderShortExit && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish && - mConditions.isXLHLowAttachedLL && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL && - mConditions.isXTSCurrentCrossedUnderNearest) && - ( - // - mConditions.isXCHLHSameLLs - // - || - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Stop Outs ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - || - // - ( - // - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - ((mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXTDBullCrossedUnderBear) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentCrossedOverFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXLHHHDecreased && - mConditions.isXCHLHMCLCLLSame) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedUnderNearest) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price In Signal Range ... - // All Neutural ... - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedUnderNearest) && - ( - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXTMStartBearish && - mConditions.isXTDSignalCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin && - (mConditions.isXTSAllSame || - mConditions.isXTSCurrentMin)) && - ( - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverNearest && - ( - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTMVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXLHPriceCrossedUnderSignal && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXTDBullCrossedUnderBear && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXLHHHDecreased && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverFarest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Under Signal ... - // All TM/AMA Bullish ... - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame) && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMABullish && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMBearish && - ( - // - mConditions.isXAMANeutural - // - || - // - (mConditions.isXAMABearish && - mConditions.isXTSCurrentCrossedOverNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXCHLHMCLCLLSame && - ( - // - (mConditions.isXAMAStartBearish && - ( - // - mConditions.isXTMStartBearish - // - || - // - mConditions.isXTSCurrentUnderMediest - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - ( - mConditions.isXTSCurrentMax && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTSCurrentMax && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXTMStartBearish) && - (mConditions.isXAMANeutural && - mConditions.isXAMAEndBullish)) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXTMStartBearish && - mConditions.isXAMANeutural && - mConditions.isXAMAEndBullish) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentCrossedUnderNearest) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCLLSame) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // Both HH and LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXFIOverZero && - ( - // - ((mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHLHMCLCLLSame) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - ((!mConditions.isXCHMALCTrendsUp && - !mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - (mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale && - mConditions.isXTSCurrentMin && - mConditions.isXLHLLIncreased && - mConditions.isXLHPriceCrossedUnderSignal && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXFIOverZero && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - ((mConditions.isXCHMAMCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXLHHHDecreased && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedUnderFarest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // LL Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTSAllSame && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMin && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL && - mConditions.isXTSCurrentCrossedUnderFarest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullCrossedUnderBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXLHHHIncreased && - mConditions.isXTSCurrentCrossedUnderFarest) && - ( - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - || - // - ((!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXTSAllSame && - ( - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMASCUnderMin && - (mConditions.isXCHLHSameLLs || - mConditions.isXCHLHSCMCLLSame)) && - ( - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price In Signal Range ... - // All Neutural ... - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXCHMASCUnderMin && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXLHHHIncreased) - // - || - // - (mConditions.isXTSCurrentCrossedOverNearest && - ( - // - ((mConditions.isXCHLHSameLLs && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCLLSame) && - ( - // - (mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXCHLHSCMCLLSame && - ( - // - (mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest) - // - || - // - (mConditions.isXAMAVale && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - (mConditions.isXLHLowAttachedLL && - ( - // - mConditions.isXCHLHSameLLs - // - || - // - mConditions.isXCHLHSCMCLLSame - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXLHHHIncreased) && - ( - // - ((mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) && - ( - // - mConditions.isXTDBullCrossedUnderBear - // - || - // - mConditions.isXLHPriceCrossedUnderSignal - // - || - // - (!mConditions.isXCHMASCTrendsUp && - !mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTSCurrentCrossedOverMediest && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - (mConditions.isXAMABearish && - mConditions.isXTMNeutural && - mConditions.isXTMEndBearish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHLHSCMCLLSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Under Signal ... - // Otherwises ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXLHLowAttachedLL && - mConditions.isXAMAStartBearish && - mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXLHPriceCrossedUnderSignal) - // - || - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDSignalOverBear && - ( - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXTSCurrentCrossedOverNearest && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - || - // - ((mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXFICrossedOverZero) && - ( - // - (mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullCrossedUnderBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXCHMASCCrossedUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - ((!mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - ( - // - ( - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - (mConditions.isXLHPriceInSignalRange && - ( - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price In Signal Range ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Under Signal ... - // All Bearish ... - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - mConditions.isXRSICrossedUnderShortExit - // - || - // - (mConditions.isXTDBullCrossedUnderBear && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTSCurrentOverMediest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Over Signal ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - ((!mConditions.isXLHPriceOverSignal && - !mConditions.isXLHPriceUnderSignal && - !mConditions.isXLHPriceInSignalRange && - !mConditions.isXLHPriceCrossedOverSignal && - !mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if SC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if MC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // Resolve Guard Attacks ... - // not LL and HH Same In Length ... - // Price Free ... - // Check if LC Fast Under Slow But Trends Down ... - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXTDBullCrossedUnderBear && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTSCurrentMin && - 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) && - // - ( - false) - // - ) - // - || - // - // XCHMACC 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 ... - // - // XCHMACC Short ... - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - (mConditions.isXTMNeutural && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXTDBullOverBear && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXLHHHDecreased && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentOverNearest) - // - || - // - ((mConditions.isXTSCurrentMin && - mConditions.isXTDBullOverBear) && - ( - // - mConditions.isXTSCurrentCrossedUnderFarest - // - || - // - (mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXLHPriceCrossedUnderSignal) - // - || - // - (mConditions.isXLHHHDecreased && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMASCFastUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXLHLowAttachedLL && - mConditions.isXRSICrossedUnderShortExit) - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXLHHHIncreased && - mConditions.isXTDBullOverBear && - mConditions.isXLHLowAttachedLL && - mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTSCurrentMin && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentUnderFarest && - mConditions.isXTSCurrentUnderMediest && - mConditions.isXTDBullCrossedUnderBear) - // - || - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXCHMASCUnderMax && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullUnderBear) - // - ) - // - ) - // - || - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTSCurrentOverNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXLHLowAttachedLL && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXTSCurrentUnderFarest) - // - || - // - (mConditions.isXTSAllSame && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMACC Short ... - // PriceUnderSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXCHMASCTrendsUp && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsUp) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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.isXAMABullish && - mConditions.isXTDBullOverBear) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentOverNearest && - mConditions.isXLHPriceCrossedOverSignal && - 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) && - // - ( - false) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - // XCHMA Shorts ... - // Resolve Guard Attacks ... - || - // - ( - // - (mConditions.isXTSCurrentOverNearest && - ( - // - (mConditions.isXTSCurrentCrossedOverNearest && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXCHMALCVale && - mConditions.isXAMAEndBullish) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABullish && - mConditions.isXCHMALCVale) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale && - (mConditions.isXAMABullish || - mConditions.isXAMAStartBullish)) - // - || - // - ((mConditions.isXCHMAMCFastUnderSlow && - (mConditions.isXCHMAMCTrendsDown || - (!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown))) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - (mConditions.isXTDSignalCrossedOverBear && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMABullish) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXTMStartBearish && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverMediest && - ( - // - (((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) || - (mConditions.isXTMEndBearish && - mConditions.isXAMAEndBearish)) && - ( - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXCHLHSCMCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXLHLLDecreased && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMALCVale && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXAMAStartBearish && - mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceOverSignal) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXCHMAMCPeak && - mConditions.isXTMEndBearish && - mConditions.isXLHHHIncreased && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - ((mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullOverBear && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin) && - ( - // - ((mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) && - ( - // - mConditions.isXLHHHIncreased - // - || - // - (mConditions.isXLHLowAttachedLL && - mConditions.isXTDSignalCrossedUnderBear && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - || - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXCHMASCUnderMin && - mConditions.isXLHPriceInSignalRange) && - ( - // - mConditions.isXTSAllSame - // - || - // - (mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTDSignalCrossedOverBear && - mConditions.isXTSCurrentCrossedOverNearest) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXLHLLDecreased && - mConditions.isXCHMASCUnderMin) && - ( - // - mConditions.isXTSCurrentMin - // - || - // - mConditions.isXTSCurrentOverFarest - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastUnderSlow && - (mConditions.isXCHMAMCTrendsDown || - (!mConditions.isXCHMAMCTrendsUp && - !mConditions.isXCHMAMCTrendsDown))) && - ( - // - ((mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin) && - ( - // - (mConditions.isXTDBullishVale && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame) - // - || - // - (mConditions.isXTDSignalVale && - ( - // - mConditions.isXCHLHSameLLs - // - || - // - mConditions.isXCHLHMCLCHHSame - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceUnderSignal) - // - ) - // - ) - // - || - // - (mConditions.isXRSICrossedUnderShortExit && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMin && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXAMANeutural) && - ( - // - mConditions.isXAMAEndBullish - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXLHHHIncreased && - mConditions.isXTSCurrentCrossedUnderFarest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCVale && - mConditions.isXAMAStartBearish) && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXLHHHIncreased && - mConditions.isXTMStartBearish && - mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceOverSignal && - mConditions.isXTDBullCrossedUnderBear && - mConditions.isXTSCurrentCrossedUnderFarest && - mConditions.isXTSCurrentCrossedUnderNearest && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXTMNeutural && - mConditions.isXTMEndBearish && - mConditions.isXLHHHIncreased && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXTMEndBearish && - mConditions.isXTSCurrentMin && - mConditions.isXLHHHIncreased && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - || - // - (mConditions.isXRSICrossedUnderShortExit && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullCrossedUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentOverFarest && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXAMAEndBullish) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDSignalVale && - mConditions.isXTDBullishVale) - // - ) - // - ) - // - || - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - mConditions.isXCHMASCUnderMin - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastUnderSlow) && - ( - // - (mConditions.isXTDBullCrossedOverBear && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXLHLLDecreased && - mConditions.isXCHMASCUnderMin) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - ((mConditions.isXCHMALCVale && - mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXTSCurrentCrossedUnderNearest) && - ( - // - (mConditions.isXLHLLDecreased && - ( - // - (mConditions.isXAMAStartBearish && - mConditions.isXLHLowAttachedLL) - // - || - // - (mConditions.isXLHLowAttachedLL && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - || - // - (mConditions.isXLHHHDecreased && - mConditions.isXTSCurrentCrossedUnderMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMin && - mConditions.isXCHMASCUnderMin && - mConditions.isXLHHHSameInLength && - mConditions.isXLHLLSameInLength && - mConditions.isXLHPriceInSignalRange) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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.isXCHMASCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXCHMASCUnderMin && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest && - mConditions.isXTSCurrentCrossedOverFarest) - // - || - // - ((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 ... - - // - // Common Conditions ... - bool XCHMAMNHasLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - double nonSC2[] = { - mConditions.chmaMcFasts[2], - mConditions.chmaMcSlows[2], - mConditions.chmaLcFasts[2], - mConditions.chmaLcSlows[2], - }; - - // - double nonSCMax2 = GetMax(nonSC2); - double nonSCMin2 = GetMax(nonSC2); - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - mConditions.isXCHMASCCrossedOverMin && - mConditions.chmaScFasts[2] < nonSCMin2 && - mConditions.chmaScSlows[2] < nonSCMin2 - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForLong( - mConditions, - true, // XCHMA Min - true, // XCHMA Max - false, // XCHMA Cycles - false, // XCHMA Peaks - false, // XCHMA Trend Powers - true, // XOBD - true // XTS - ) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XCHMAMNHasSpecifiedLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XCHMAMNHasLongSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown) && - ( - // - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMALCTrendsDown) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMAMCVale && - mConditions.isXCHLHMCLCLLSame) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXLHHHDecreased && - mConditions.isXLHLLDecreased && - mConditions.isXTMStartBullish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXLHHHDecreased && - mConditions.isXLHLLDecreased && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMALCTrendsDown) && - ( - // - (((mConditions.isXTMVale || - mConditions.isXTMNeutural) && - mConditions.isXTMEndBearish) && - (mConditions.isXAMANeutural || - mConditions.isXAMAEndBearish) && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check Conditions if Price is Under Signal ... - ( - // - ((mConditions.isXLHPriceUnderSignal || - mConditions.isXLHPriceCrossedUnderSignal) && - ( - // - // Next Step is to Check LL and HH Same Style ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMALCTrendsDown) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXLHLLDecreased && - mConditions.isXCHLHMCLCHHSame) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - // LC Vale ... - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) && - ( - // - mConditions.isXCHMASCTrendsDown - // - || - // - (mConditions.isXTMVale && - mConditions.isXAMAVale && - mConditions.isXLHLLIncreased && - mConditions.isXCHLHMCLCHHSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - || - // - ((mConditions.isXCHMAMCVale && - mConditions.isXCHMAMCTrendsUp && - (mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow)) && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMALCTrendsDown) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown) && - ( - // - ((mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale) && - ( - // - mConditions.isXCHMAMCVale - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXLHHHDecreased && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - ) - // - ) - // - || - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXCHLHMCLCLLSame) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderNearest) - // - || - // - (mConditions.isXCHMALCVale && - ( - // - mConditions.isXCHMASCTrendsDown - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale) - // - || - // - (mConditions.isXAMANeutural && - mConditions.isXTSCurrentMax && - mConditions.isXTDBearishVale && - mConditions.isXTMStartBullish && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - (mConditions.isXCHMALCTrendsDown && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - (mConditions.isXCHLHMCLCHHSame || - mConditions.isXCHLHMCLCLLSame) && - mConditions.isXTSCurrentUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown) && - ( - // - mConditions.isXCHMALCVale - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) && - ( - // - ((mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) - // - || - // - (mConditions.isXTMStartBullish && - mConditions.isXAMAStartBullish) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXTDBullUnderBear) - // - ) - // - ) - // - || - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXTDSignalUnderBear) - // - || - // - mConditions.isXCHMASCTrendsDown - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // LC Vale ... - (mConditions.isXCHMALCVale && - ( - // - (mConditions.isXCHMAMCVale && - ( - // - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCHHSame && - 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - false) - // - ) - // - || - // - // XCHMAMN Long ... - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - false) - // - ) - // - || - // - // XCHMAMN Long ... - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // XCHMAMN Long ... - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - false) - // - ) - // - || - // - // XCHMAMN Long ... - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - false) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderFarest) - // - ) - // - ) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMAMN Long ... - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - false) - // - ) - // - || - // - // XCHMAMN Long ... - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - || - // - (mConditions.isXCHMASCPeak && - mConditions.isXCHMALCVale && - mConditions.isXTSCurrentMax && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastOverSlow && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - // Check if MC Fast Under Slow ... - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXCHMALCTrendsDown && - mConditions.isXCHMALCFastOverSlow) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMALCTrendsUp && - ( - // - (mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - mConditions.isXTDSignalUnderBear - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXCHMALCTrendsUp) - // - || - // - ((mConditions.isXTMNeutural && - mConditions.isXAMANeutural) && - ( - // - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMAMN Long ... - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXTMBullish && - mConditions.isXAMABullish) && - ( - // - (mConditions.isXLHHHIncreased && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXTDSignalUnderBear && - mConditions.isXTSCurrentUnderNearest && - mConditions.isXTSCurrentCrossedUnderNearest) - // - || - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXCHMASCFastCrossedOverSlow && - mConditions.isXTSCurrentCrossedOverFarest && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - || - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHHighAttachedHH && - mConditions.isXLHPriceCrossedOverSignal && - mConditions.isXTSCurrentCrossedOverNearest && - mConditions.isXTSCurrentCrossedOverMediest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMAMN Long ... - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check LC Fast Under Slow ... - ((mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow) && - ( - // - (mConditions.isXCHMALCTrendsUp && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - - // - // Common Conditions ... - bool XCHMAMNHasShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - double nonSC2[] = { - mConditions.chmaMcFasts[2], - mConditions.chmaMcSlows[2], - mConditions.chmaLcFasts[2], - mConditions.chmaLcSlows[2], - }; - - // - double nonSCMax2 = GetMax(nonSC2); - double nonSCMin2 = GetMax(nonSC2); - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - mConditions.isXCHMASCCrossedUnderMin && - mConditions.chmaScFasts[2] > nonSCMin2 && - mConditions.chmaScSlows[2] > nonSCMin2 - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForLong( - mConditions, - true, // XCHMA Min - true, // XCHMA Max - false, // XCHMA Cycles - false, // XCHMA Peaks - false, // XCHMA Trend Powers - true, // XOBD - true // XTS - ) - // - ) - // - ; - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XCHMAMNHasSpecifiedShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XCHMAMNHasShortSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSAllSame && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalOverBear) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXTMBearish || - mConditions.isXTMNeutural) && - mConditions.isXAMANeutural && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXLHLLIncreased && - mConditions.isXTSCurrentOverNearest) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentOverFarest) && - ( - // - (mConditions.isXFIOverZero && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - mConditions.isXAMANeutural && - mConditions.isXAMAEndBullish && - mConditions.isXTMStartBearish) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentOverNearest && - mConditions.isXTSCurrentOverMediest && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMALCVale && - mConditions.isXTDBullOverBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXFICrossedUnderZero && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - mConditions.isXRSICrossedUnderShortExit - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXTSCurrentOverFarest && - (mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow)) && - ( - // - (mConditions.isXTMNeutural && - mConditions.isXAMAStartBearish) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCVale && - mConditions.isXCHMALCVale && - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow))) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXAMANeutural && - mConditions.isXTMEndBearish && - mConditions.isXTSCurrentOverMediest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - // - // Check if SC Fast Over Slow ... - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXTSAllSame && - mConditions.isXAMABearish && - mConditions.isXLHLLDecreased && - mConditions.isXCHMALCFastOverSlow) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - ((mConditions.isXFIOverZero && - mConditions.isXTDBullOverBear && - mConditions.isXFICrossedOverZero) && - ( - // - (mConditions.isXTSCurrentMax && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXTSAllSame && - mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXCHMASCFastCrossedUnderSlow) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) - // - || - // - ((mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMAMCFastUnderSlow) && - ( - // - (mConditions.isXCHMALCVale && - mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCLLSame && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXCHMASCCrossedUnderMin && - mConditions.isXTSCurrentCrossedUnderFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - - // - // Common Conditions ... - bool XCHMAMXHasLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - double nonSC2[] = { - mConditions.chmaMcFasts[2], - mConditions.chmaMcSlows[2], - mConditions.chmaLcFasts[2], - mConditions.chmaLcSlows[2], - }; - - // - double nonSCMax2 = GetMax(nonSC2); - double nonSCMin2 = GetMax(nonSC2); - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - mConditions.isXCHMASCCrossedOverMax && - mConditions.chmaScFasts[2] < nonSCMax2 && - mConditions.chmaScSlows[2] < nonSCMax2 && - MathAbs(nonSCMax2 - mConditions.chmaScFasts[2]) > MathAbs(mConditions.chmaScFasts[2] - mConditions.chmaScSlows[2]) && - MathAbs(nonSCMax2 - mConditions.chmaScSlows[2]) > MathAbs(mConditions.chmaScFasts[2] - mConditions.chmaScSlows[2]) - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForLong( - mConditions, - true, // XCHMA Min - true, // XCHMA Max - false, // XCHMA Cycles - false, // XCHMA Peaks - false, // XCHMA Trend Powers - true, // XOBD - true // XTS - ) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XCHMAMXHasSpecifiedLongSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XCHMAMXHasLongSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMALCPeak && - ( - // - (mConditions.isXCHMALCTrendsDown && - ( - // - ( - // - mConditions.isXCHMASCPeak - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural && - mConditions.isXCHLHSameHHs && - mConditions.isXLHHighAttachedHH && - mConditions.isXTDSignalUnderBear) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (((mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow) && - (mConditions.isXCHMALCFastUnderSlow || - mConditions.isXCHMALCFastCrossedUnderSlow)) && - ( - // - (mConditions.isXLHHHDecreased && - mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear && - mConditions.isXLHPriceCrossedOverSignal) - // - || - // - (mConditions.isXTMNeutural && - mConditions.isXAMANeutural) - // - || - // - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - || - // - (((mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMALCTrendsDown) || - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown) || - (mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown)) && - ( - // - (mConditions.isXCHMAMCPeak - // - || - // - mConditions.isXRSICrossedOverLongExit) - // - || - // - ((mConditions.isXCHMAMCFastUnderSlow || - mConditions.isXCHMAMCFastCrossedUnderSlow) && - ( - // - (mConditions.isXTMBullish && - mConditions.isXAMABullish && - mConditions.isXCHLHSCMCHHSame) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - (mConditions.isXCHMASCTrendsDown && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - bool XCHMAMXHasShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - double nonSC2[] = { - mConditions.chmaMcFasts[2], - mConditions.chmaMcSlows[2], - mConditions.chmaLcFasts[2], - mConditions.chmaLcSlows[2], - }; - - // - double nonSCMax2 = GetMax(nonSC2); - double nonSCMin2 = GetMax(nonSC2); - - // - // Start Analysing Market based On Conditions ... - result = - // - // Base Condition: - // each Strategy must has a Base Conditions, which they are usually common combinations - // of Market Properties that must be happens to lookup for signals ... - ( - // - mConditions.isXCHMASCCrossedUnderMax && - mConditions.chmaScFasts[2] > nonSCMax2 && - mConditions.chmaScSlows[2] > nonSCMax2 - // - ) - // - && - // - // Next Step is combine sorts of Conditions which make our choice - // so Exact in Market ... - ( - // - IsReadyForShort( - mConditions, - true, // XCHMA Min - true, // XCHMA Max - false, // XCHMA Cycles - false, // XCHMA Peaks - false, // XCHMA Trend Powers - true, // XOBD - true // XTS - ) - // - ) - // - ; - - // - return result; - } - - // - // Symbol and Type Specific Conditions ... - bool XCHMAMXHasSpecifiedShortSignal( - X5MarketConditions &mConditions // - ) - { - // - bool result = false; - - // - // Check Common Signal Conditions ... - result = XCHMAMXHasShortSignal(mConditions); - if (!result) - { - return result; - } - - // - // Validate Symbol ... - result = IsValidSymbolPeriod(); - if (!result) - { - return result; - } - - // - // Now We Can Filter Conditions based on Each Supported Symbol - // since we are in Correct Period ... - // NOTE: since base Common Conditions Checked Before, - // there is no need to double check them ... - - // - bool isEURUSD = IsEURUSD(); - if (isEURUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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 ... - // - // PriceInSignalRange ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTMNeutural && - mConditions.isXCHMASCVale && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXTSCurrentMin) - // - || - // - (((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) && - ( - // - (mConditions.isXAMAStartBearish && - mConditions.isXTSCurrentOverFarest) - // - || - // - (mConditions.isXCHMASCVale && - mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXLHHHIncreased && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHMAMCTrendsUp && - mConditions.isXAMAStartBearish && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXTSCurrentMin && - mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) && - ( - // - ((mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak) && - ( - // - (mConditions.isXTMVale && - mConditions.isXAMAVale) - // - || - // - (mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - || - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXCHMAMCTrendsDown) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXTMBearish && - mConditions.isXCHMAMCPeak && - mConditions.isXAMAStartBearish && - mConditions.isXTSCurrentOverFarest) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXLHHHDecreased && - mConditions.isXTMStartBearish && - mConditions.isXCHMALCTrendsUp && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - mConditions.isXCHMALCPeak - // - || - // - (mConditions.isXTSAllSame && - mConditions.isXAMAEndBullish && - mConditions.isXTMStartBearish && - mConditions.isXTDBullOverBear && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - || - // - (((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow)) && - ( - // - ( - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL) && - ( - // - (mConditions.isXTSCurrentMin && - mConditions.isXCHLHMCLCHHSame) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTDBullOverBear && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceUnderSignal ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHLHSameHHs && - mConditions.isXCHLHSameLLs && - mConditions.isXTSCurrentMin && - mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish && - mConditions.isXLHLowAttachedLL && - ((mConditions.isXCHMASCFastOverSlow || - mConditions.isXCHMASCFastCrossedOverSlow) && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - (mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow))) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // Check Conditions if Price is Over Signal ... - ( - // - ((mConditions.isXLHPriceOverSignal || - mConditions.isXLHPriceCrossedOverSignal) && - ( - // - // Next Step is to Check LL and HH Same Style ... - // - // PriceOverSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - (mConditions.isXTMBearish && - mConditions.isXAMABearish && - mConditions.isXCHMAMCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXCHMAMCTrendsUp) - // - || - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMAMCTrendsUp && - (mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow)) - // - || - // - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMASCVale && - mConditions.isXTSCurrentMin && - mConditions.isXTMStartBearish && - mConditions.isXAMAStartBearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - ((mConditions.isXTMBearish && - mConditions.isXCHMAMCPeak && - mConditions.isXAMANeutural && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXCHLHMCLCLLSame) && - ( - // - mConditions.isXTSCurrentOverFarest - // - || - // - (mConditions.isXTSCurrentMin && - mConditions.isXCHMAMCTrendsDown && - mConditions.isXCHMALCTrendsDown) - // - ) - // - ) - // - || - // - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMAMCPeak && - mConditions.isXCHMALCPeak && - mConditions.isXAMANeutural && - mConditions.isXTMStartBearish) - // - ) - // - ) - // - ) - // - ) - // - || - // - // PriceOverSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - ((mConditions.isXCHMASCTrendsUp && - (mConditions.isXCHMASCFastUnderSlow || - mConditions.isXCHMASCFastCrossedUnderSlow)) && - ( - // - (mConditions.isXFIUnderZero && - (mConditions.isXTMBearish || - mConditions.isXTMStartBearish) && - (mConditions.isXAMABearish || - mConditions.isXAMAStartBearish) && - (mConditions.isXTDBullUnderBear && - mConditions.isXTDSignalUnderBear)) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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 ... - // - // PriceFree ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - || - // - // PriceFree ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - false - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDJPY = IsUSDJPY(); - if (isUSDJPY) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - false) - // - ) - // - || - // - // XCHMAMX Short ... - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - false) - // - ) - // - || - // - // XCHMAMX Short ... - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - false) - // - ) - // - || - // - // XCHMAMX 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 ... - // - // XCHMAMX Short ... - // PriceUnderSignal ... - // Check if Both LL and HH Same In Length ... - ((mConditions.isXLHLLSameInLength && - mConditions.isXLHHHSameInLength) && - // - ( - false) - // - ) - // - || - // - // XCHMAMX Short ... - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - false) - // - ) - // - || - // - // XCHMAMX Short ... - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isUSDCHF = IsUSDCHF(); - if (isUSDCHF) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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) && - // - ( - false) - // - ) - // - || - // - // XCHMAMX Short ... - // PriceInSignalRange ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - false) - // - ) - // - || - // - // XCHMAMX Short ... - // PriceInSignalRange ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - false) - // - ) - // - || - // - // XCHMAMX Short ... - // PriceInSignalRange ... - // Not Same LL or HH in Lenght ... - ((!mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check LC Fast Over Slow ... - ((mConditions.isXCHMALCFastOverSlow || - mConditions.isXCHMALCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHLHSameLLs && - mConditions.isXTDBullOverBear && - mConditions.isXCHLHSCMCHHSame && - mConditions.isXLHLowAttachedLL) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - ((mConditions.isXTMBearish && - mConditions.isXAMABearish) && - ( - // - (mConditions.isXCHMALCFastOverSlow && - ( - // - (mConditions.isXCHMALCTrendsUp && - mConditions.isXCHMASCFastOverSlow) - // - || - // - (mConditions.isXCHMALCPeak && - mConditions.isXTSCurrentMin && - mConditions.isXTSCurrentCrossedUnderNearest) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // XCHMAMX Short ... - // PriceUnderSignal ... - // Check If LL Same In Length ... - ((mConditions.isXLHLLSameInLength && - !mConditions.isXLHHHSameInLength) && - // - ( - false) - // - ) - // - || - // - // XCHMAMX Short ... - // PriceUnderSignal ... - // Check If HH is Same In Length ... - ((mConditions.isXLHHHSameInLength && - !mConditions.isXLHLLSameInLength) && - // - ( - // - // Check if MC Fast Over Slow ... - ((mConditions.isXCHMAMCFastOverSlow || - mConditions.isXCHMAMCFastCrossedOverSlow) && - ( - // - (mConditions.isXCHMALCFastOverSlow && - ( - // - (mConditions.isXTSAllSame && - mConditions.isXCHMALCPeak && - mConditions.isXCHLHSCMCLLSame && - mConditions.isXLHLowAttachedLL && - mConditions.isXLHPriceCrossedUnderSignal) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) && - // - ( - false) - // - ) - // - || - // - // 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) - // - ) - // - ) - // - ) - // - ) - // - ) - // - ; - } - - // - bool isXAUUSD = IsXAUUSD(); - if (isXAUUSD) - { - // - // Start Analysing Market based On Conditions ... - result = - // - // 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; - } - - // - // Signal Conditions Filtering ... - - // - // Here we have to Implement all Signals Conditional Filtering ... - // this Filtering works based on Symbol and Period .... - // this means each signaller (Provider) has their own implementation based on - // Specific Period/Symbol parir ... - - // - bool IsEURUSD() - { - // - string symbolIdentifiers[] = { - "EUR", - "USD" // - }; - - // - bool result = Contains( - symbolIdentifiers, - GetSymbol() // - ); - - // - return result; - } - - // - bool IsUSDJPY() - { - // - string symbolIdentifiers[] = { - "USD", - "JPY" // - }; - - // - bool result = Contains( - symbolIdentifiers, - GetSymbol() // - ); - - // - return result; - } - - // - bool IsUSDCHF() - { - // - string symbolIdentifiers[] = { - "USD", - "CHF" // - }; - - // - bool result = Contains( - symbolIdentifiers, - GetSymbol() // - ); - - // - return result; - } - - // - bool IsXAUUSD() - { - // - string symbolIdentifiers[] = { - "XAU", - "USD" // - }; - - // - bool result = Contains( - symbolIdentifiers, - GetSymbol() // - ); - - // - return result; - } - - // - bool IsValidSymbol() - { - // - bool isEURUSD = IsEURUSD(); - bool isUSDJPY = IsUSDJPY(); - bool isUSDCHF = IsUSDCHF(); - bool isXAUUSD = IsXAUUSD(); - - // - bool result = - // - isEURUSD - // - || - // - isUSDJPY - // - || - // - isUSDCHF - // - || - // - isXAUUSD - // - ; - - // - return result; - } - - // - bool IsValidPeriod() - { - // - ENUM_TIMEFRAMES period = GetPeriod(); - - // - bool result = period == PERIOD_M5; - - // - return result; - } - - // - bool IsValidSymbolPeriod() - { - // - bool result = - // - IsValidSymbol() - // - && - // - IsValidPeriod() - // - ; - - // - return result; - } - - // - // Detect Signal ... - bool HasSpecificSignal( - int barIndex, // Specified Bar Index ... - ENUM_POSITION_TYPE mType, // Specific Signal Type ... - string &provider, // Signal Provider ... - int &signalPusher, // Number Of Same Time Signals ... - X5MarketConditions &mConditions // Specified Market Conition ... - ) - { - // - bool result = false; - - // - // Validate Signal Type is Enables ... - bool isLong = IsLong(mType); - result = - (isLong && mIsLongEnable) || - (!isLong && mIsShortEnable); - if (!result) - { - return result; - } - - // - // Now we have to Filter based on Enabled Signal Providers ... - - // - // Long ... - if (isLong && mIsLongEnable) - { - // - XSignal lSignal; - - // - signalPusher = 0; - - // - bool hasX5XSPSignal = false; - bool hasXTDSignal = false; - bool hasXTAMSignal = false; - bool hasXSISignal = false; - bool hasXTSFISignal = false; - bool hasXOBDLHSignal = false; - bool hasXCHMACCSignal = false; - bool hasXCHMAMNSignal = false; - bool hasXCHMAMXSignal = false; - - // - // XPS ... - if (mIsX5XSPSignalProviderEnable) - { - // - hasX5XSPSignal = X5XSPHasSpecifiedLongSignal( - mConditions // - ); - - // - if (hasX5XSPSignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(X5XSP); - } - - // - signalPusher++; - } - } - - // - // XTD ... - if (mIsXTDSignalProviderEnable) - { - // - hasXTDSignal = XTDHasSpecifiedLongSignal( - mConditions // - ); - - // - if (hasXTDSignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XTD); - } - - // - signalPusher++; - } - } - - // - // XTAM ... - if (mIsXTAMSignalProviderEnable) - { - // - hasXTAMSignal = XTAMHasSpecifiedLongSignal( - mConditions // - ); - - // - if (hasXTAMSignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XTAM); - } - - // - signalPusher++; - } - } - - // - // XSI ... - if (mIsXSISignalProviderEnable) - { - // - hasXSISignal = XSIHasSpecifiedLongSignal( - mConditions // - ); - - // - if (hasXSISignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XSI); - } - - // - signalPusher++; - } - } - - // - // XTSFI ... - if (mIsXTSFISignalProviderEnable) - { - // - hasXTSFISignal = XTSFIHasSpecifiedLongSignal( - mConditions // - ); - - // - if (hasXTSFISignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XTSFI); - } - - // - signalPusher++; - } - } - - // - // XOBDLH ... - if (mIsXOBDLHSignalProviderEnable) - { - // - hasXOBDLHSignal = XOBDLHHasSpecifiedLongSignal( - mConditions // - ); - - // - if (hasXOBDLHSignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XOBDLH); - } - - // - signalPusher++; - } - } - - // - // XCHMACC ... - if (mIsXCHMACCSignalProviderEnable) - { - // - hasXCHMACCSignal = XCHMACCHasSpecifiedLongSignal( - mConditions // - ); - - // - if (hasXCHMACCSignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XCHMACC); - } - - // - signalPusher++; - } - } - - // - // XCHMAMN ... - if (mIsXCHMAMNSignalProviderEnable) - { - // - hasXCHMAMNSignal = XCHMAMNHasSpecifiedLongSignal( - mConditions // - ); - - // - if (hasXCHMAMNSignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XCHMAMN); - } - - // - signalPusher++; - } - } - - // - // XCHMAMX ... - if (mIsXCHMAMXSignalProviderEnable) - { - // - hasXCHMAMXSignal = XCHMAMXHasSpecifiedLongSignal( - mConditions // - ); - - // - if (hasXCHMAMXSignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XCHMAMX); - } - - // - signalPusher++; - } - } - - // - result = - // - hasX5XSPSignal - // - || - // - hasXTDSignal - // - || - // - hasXTAMSignal - // - || - // - hasXSISignal - // - || - // - hasXTSFISignal - // - || - // - hasXOBDLHSignal - // - || - // - hasXCHMACCSignal - // - || - // - hasXCHMAMNSignal - // - || - // - hasXCHMAMXSignal - // - ; - - // - if (result) - { - return result; - } - } - - // - // Short ... - if (!isLong && mIsShortEnable) - { - // - XSignal sSignal; - - // - signalPusher = 0; - - // - bool hasX5XSPSignal = false; - bool hasXTDSignal = false; - bool hasXTAMSignal = false; - bool hasXSISignal = false; - bool hasXTSFISignal = false; - bool hasXOBDLHSignal = false; - bool hasXCHMACCSignal = false; - bool hasXCHMAMNSignal = false; - bool hasXCHMAMXSignal = false; - - // - // XPS ... - if (mIsX5XSPSignalProviderEnable) - { - // - hasX5XSPSignal = X5XSPHasSpecifiedShortSignal( - mConditions // - ); - - // - if (hasX5XSPSignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(X5XSP); - } - - // - signalPusher++; - } - } - - // - // XTD ... - if (mIsXTDSignalProviderEnable) - { - // - hasXTDSignal = XTDHasSpecifiedShortSignal( - mConditions // - ); - - // - if (hasXTDSignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XTD); - } - - // - signalPusher++; - } - } - - // - // XTAM ... - if (mIsXTAMSignalProviderEnable) - { - // - hasXTAMSignal = XTAMHasSpecifiedShortSignal( - mConditions // - ); - - // - if (hasXTAMSignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XTAM); - } - - // - signalPusher++; - } - } - - // - // XSI ... - if (mIsXSISignalProviderEnable) - { - // - hasXSISignal = XSIHasSpecifiedShortSignal( - mConditions // - ); - - // - if (hasXSISignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XSI); - } - - // - signalPusher++; - } - } - - // - // XTSFI ... - if (mIsXTSFISignalProviderEnable) - { - // - hasXTSFISignal = XTSFIHasSpecifiedShortSignal( - mConditions // - ); - - // - if (hasXTSFISignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XTSFI); - } - - // - signalPusher++; - } - } - - // - // XOBDLH ... - if (mIsXOBDLHSignalProviderEnable) - { - // - hasXOBDLHSignal = XOBDLHHasSpecifiedShortSignal( - mConditions // - ); - - // - if (hasXOBDLHSignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XOBDLH); - } - - // - signalPusher++; - } - } - - // - // XCHMACC ... - if (mIsXCHMACCSignalProviderEnable) - { - // - hasXCHMACCSignal = XCHMACCHasSpecifiedShortSignal( - mConditions // - ); - - // - if (hasXCHMACCSignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XCHMACC); - } - - // - signalPusher++; - } - } - - // - // XCHMAMN ... - if (mIsXCHMAMNSignalProviderEnable) - { - // - hasXCHMAMNSignal = XCHMAMNHasSpecifiedShortSignal( - mConditions // - ); - - // - if (hasXCHMAMNSignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XCHMAMN); - } - - // - signalPusher++; - } - } - - // - // XCHMAMX ... - if (mIsXCHMAMXSignalProviderEnable) - { - // - hasXCHMAMXSignal = XCHMAMXHasSpecifiedShortSignal( - mConditions // - ); - - // - if (hasXCHMAMXSignal) - { - // - if (!IsValid(provider)) - { - provider = ToString(XCHMAMX); - } - - // - signalPusher++; - } - } - - // - result = - // - hasX5XSPSignal - // - || - // - hasXTDSignal - // - || - // - hasXTAMSignal - // - || - // - hasXSISignal - // - || - // - hasXTSFISignal - // - || - // - hasXOBDLHSignal - // - || - // - hasXCHMACCSignal - // - || - // - hasXCHMAMNSignal - // - || - // - hasXCHMAMXSignal - // - ; - - // - if (result) - { - return result; - } - } - - // - return result; - } -}; - -// -// Tools ... - -// -// Model Provider Descriptor ... -struct X5ProviderDescriptor -{ - // - string symbol; // Trading Symbol - ENUM_TIMEFRAMES period; // Trading Timeframe - double staticVolume; // Static Volume for Positions - bool allowLong; // Allow Long Signals - bool allowShort; // Allow Short Signals - ENUM_X5_SIGNAL_PROVIDERS signallers[]; // Allowed Signal Providers - - // - X5ProviderInputs inputs; - XSCX5Provider *provider; - - // - XSignal signal; - X5MarketConditions conditions; - - // - // Tools ... - - // - bool Init() - { - // - bool result = false; - - // - result = this.Init( - this.symbol, - this.period, - this.signallers, - this.allowLong, - this.allowShort, - this.staticVolume // - ); - - // - return result; - } - - // - bool Init( - ENUM_X5_SIGNAL_PROVIDERS &mSignallers[], // Allowed Signal Providers - bool mAllowLong = true, // Allow Long Signals - bool mAllowShort = true, // Allow Short Signals - double mStaticVolume = 0.01 // Static Volume for Positions - ) - { - // - bool result = false; - - // - result = this.Init( - this.symbol, - this.period, - mSignallers, - mAllowLong, - mAllowShort, - mStaticVolume // - ); - - // - return result; - } - - // - bool Init( - string mSymbol, // Trading Symbol - ENUM_TIMEFRAMES mPeriod, // Trading Timeframe - ENUM_X5_SIGNAL_PROVIDERS &mSignallers[], // Allowed Signal Providers - bool mAllowLong = true, // Allow Long Signals - bool mAllowShort = true, // Allow Short Signals - double mStaticVolume = 0.01 // Static Volume for Positions - ) - { - // - bool result = false; - - // - result = - // - inputs.IsValid() && - IsValid(mSymbol) && - IsValid(mPeriod) && - NotEmpty(mStaticVolume) && - (allowLong || allowShort) && - ArraySize(mSignallers) > 0 - // - ; - if (!result) - { - return result; - } - - // - this.symbol = mSymbol; - this.period = mPeriod; - this.allowLong = mAllowLong; - this.allowShort = mAllowShort; - this.staticVolume = mStaticVolume; - - // - ENUM_X5_SIGNAL_PROVIDERS tmp[]; - Copy( - mSignallers, - tmp // - ); - Copy( - tmp, - this.signallers // - ); - - // - // Instantiate Provider ... - provider = new XSCX5Provider( - this.symbol, - this.period, - this.staticVolume // - ); - - // - // Set Long/Short State ... - - // - provider - .SetSignalTypeState( - POSITION_TYPE_BUY, - this.allowLong // - ); - - // - provider - .SetSignalTypeState( - POSITION_TYPE_SELL, - this.allowShort // - ); - - // - // Enable Required Signallers ... - provider - .SetSignalProviderStates( - this.signallers, - true // - ); - - // - // Now Must to Initialize Provider ... - result = provider.Init( - this.inputs // - ); - - // - return result; - } - - // - // Cleanup ... - void Clean() - { - // - signal.Clean(); - conditions.Clear(); - } - - // - // Validate ... - bool IsValid(bool validateInputs = true) - { - // - bool result = false; - - // - result = - // - IsValid(symbol) && - IsValid(period) && - NotEmpty(staticVolume) && - (validateInputs - ? inputs.IsValid() - : true) && - (allowLong || allowShort) && - ArraySize(signallers) > 0 - // - ; - - // - return result; - } - - // - // Check Signal ... - bool HasSignal(int barIndex = 0) - { - // - bool result = false; - - // - result = inputs.IsValid(); - if (!result) - { - return result; - } - - // - // Clear Signal and Conditions ... - Clean(); - - // - result = provider.HasSignal( - barIndex, - signal, - conditions // - ); - - // - return result; - } -}; - -// -void GetAllX5SignalProviders(ENUM_X5_SIGNAL_PROVIDERS &result[]) -{ - // - Clean(result); - - // - Add(X5NONE, result); - Add(X5XSP, result); - Add(XTD, result); - Add(XTAM, result); - Add(XSI, result); - Add(XTSFI, result); - Add(XOBDLH, result); - Add(XCHMACC, result); - Add(XCHMAMN, result); - Add(XCHMAMX, result); -} - -// -string ToString(ENUM_X5_SIGNAL_PROVIDERS value) -{ - return EnumToString(value); -} - -// -ENUM_X5_SIGNAL_PROVIDERS ToX5SignalProvider(string content) -{ - // - ENUM_X5_SIGNAL_PROVIDERS result = X5NONE; - - // - if (!IsValid(content)) - { - return result; - } - - // - if (content == ToString(X5NONE)) - { - result = X5NONE; - } - else if (content == ToString(X5XSP)) - { - result = X5XSP; - } - else if (content == ToString(XTD)) - { - result = XTD; - } - else if (content == ToString(XTAM)) - { - result = XTAM; - } - else if (content == ToString(XSI)) - { - result = XSI; - } - else if (content == ToString(XTSFI)) - { - result = XTSFI; - } - else if (content == ToString(XOBDLH)) - { - result = XOBDLH; - } - else if (content == ToString(XCHMACC)) - { - result = XCHMACC; - } - else if (content == ToString(XCHMAMN)) - { - result = XCHMAMN; - } - else if (content == ToString(XCHMAMX)) - { - result = XCHMAMX; - } - - // - return result; -} - -// \ No newline at end of file diff --git a/Classes/x-saherelm.x5.xea.class.mq5 b/Classes/x-saherelm.x5.xea.class.mq5 deleted file mode 100644 index e03f1488..00000000 --- a/Classes/x-saherelm.x5.xea.class.mq5 +++ /dev/null @@ -1,308 +0,0 @@ -/////////////////////////////////////////////////////// -// -// SaherElm IT Center MQL5 Class Library -// ---------------------------------------------- -// Name: XSCX5EA -// Description: provides all X5 EA requirements ... -// - X5 Provider; -// -// -// Maintainer: -// ------------ -// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) -// -////////////////////////////////////////////////////// -// -// Global Properties ... -#property library -#property copyright "Copyright 2023, SaherElm IT Center" -#property link "https://www.saherelm.ir" -#property version "1.00" -#property strict - -// -// Imports ... -#include "../Classes/x-saherelm.xea.class.mq5" -#include "../Classes/x-saherelm.x5.provider.class.mq5" - -// -// Define On Signal Event Handler Type Specified for X5 ... -typedef void (*TX5OnSignal)(X5ProviderDescriptor &descriptor); - -// -// Class Definition ... - -class XSCX5EA : public XSCBaseEA -{ - // - // Public ... -public: - // - // Props ... - - // - // Constructors ... - XSCX5EA( - // - // XTrade Class Requirements ... - int slippage, // Specify Slippage - ulong magicNumber, // Specify Magic Number - int manageInterval, // Manager Check Intervals Seconds - double maxAllowedSpread, // Max Allowed Spred for Opening Trades - int maxAllowedPositions, // Max Allowed Positions - double maxAllowedDrawdownFactor, // Max Allowed Drawdown Factor - double staticVolume, // Static Volume for Positions - // - // Position Management ... - bool allowLong = true, // Allow Long Trades - bool allowShort = true, // Allow Short Trades - double minProfitPerTrade = 0, // Min Profit Per Trade based On Volume Factor (Hedge) - double minProfitPerVolumeFactor = 0, // Min Volume Factor for Calculating Profit (Hedge) - // - // Event Handlers ... - TOnStopLoss onStopLossTriggered = NULL, // On StopLoass Triggered Event Handler - TOnTakeProfit onTakeProfitTriggered = NULL, // On TakeProfit Triggered Event Handler - TOnDealsChanged onDealsChangedHandler = NULL, // On Deals Changed Event Handler - TOnOrdersChanged onOrdersChangedHandler = NULL, // On Orders Changed Event Handler - TOnPositionsChanged onPositionsChangedHandler = NULL, // On Positions Changed Event Handler - TOnTradeStateChanged onTradeStateChangedHandler = NULL, // On Trade State Changed Event Handler - // - TOnSignal onSignalHandler = NULL, // On Signal Event Handler - // - // Log Handler ... - bool enableAlerts = true, // Enable Alerts - bool logAlerts = true, // Log Alerts - bool terminalAlerts = false, // Terminal Alerts - bool mailAlerts = false, // Mail Alerts - bool pushAlerts = false // Push Alerts - ) : XSCBaseEA(slippage, - magicNumber, - manageInterval, - maxAllowedSpread, - maxAllowedPositions, - maxAllowedDrawdownFactor, - allowLong, - allowShort, - minProfitPerTrade, - minProfitPerVolumeFactor, - staticVolume, - onStopLossTriggered, - onTakeProfitTriggered, - onDealsChangedHandler, - onOrdersChangedHandler, - onPositionsChangedHandler, - onTradeStateChangedHandler, - enableAlerts, - logAlerts, - terminalAlerts, - mailAlerts, - pushAlerts // - ) - { - } - - // - // Deconstructor ... - ~XSCX5EA() {} - - // - // Properties Getter(s) / Setter(s) ... - - // - // Add X5 Specified Signal Event Handler ... - void AddOnSignalEventHandler(TX5OnSignal listener) - { - // - Add( - listener, - mX5OnSignalEventHandlers - // - ); - } - - // - // Add Specified X5 Provider ... - bool AddProvider(X5ProviderDescriptor &descriptor) - { - // - bool result = false; - - // - // Validate Inputs ... - result = descriptor.Init(); - if (!result) - { - return result; - } - - // - AddRef( - descriptor, - mDescriptors // - ); - - // - return result; - } - - // - // Overrides ... - - // - // Customize Token ... - string GetToken() override - { - return GetSpecificToken(this); - } - - // - string GetTag() override - { - return this.GetToken(); - } - - // - // Check Provider for any Guards ... - bool CheckForGuard(XGuard &guards[]) override - { - // - // TODO: Implement this ... - return false; - } - - // - // Request Provider to Collect all - // Potentially Signals and then - // filters theme here and passed them - // for Executing ... - int RequestForSignal( - XSignal &signals[] // Holds Signals ... - ) override - { - // - bool result = 0; - - // - Clean(signals); - - // - int descriptorsCount = CountDescriptors(); - if (descriptorsCount <= 0) - { - return result; - } - - // - for (int i = 0; i < descriptorsCount; i++) - { - // - X5ProviderDescriptor iDescriptor = mDescriptors[i]; - - // - bool iHasSignal = iDescriptor.HasSignal(); - if (iHasSignal) - { - // - // Here we Can double check Signals by Conditions - // for Score Base Filtering ... - - // - AddRef( - iDescriptor.signal, - signals - // - ); - - // - NotifyX5OnSignalEventHandlers(iDescriptor); - } - } - - // - result = ArraySize(signals); - - // - return result; - } - - // - // Handl Management Actions ... - // if returns true, it is going to prevent for processing forward ... - bool HandleStateManagement(XSignal &signals[]) override - { - // - // TODO: Implement this ... - return false; - } - - // - // Request for Support Signals using Guard ... - bool RequestForSupport( - XSignal &support, // Holds Support Signal, if Provided - string provider, // Positions Provided by Specific Provider - string symbol, // Trading Symbol - ENUM_POSITION_TYPE type, // Trading Type - ENUM_TIMEFRAMES period // Specified Time Frame - ) override - { - // - // TODO: Implement this ... - return false; - } - - // - // Tools ... - - // - // Protected ... -protected: - // - // Tools ... - - // - void NotifyX5OnSignalEventHandlers(X5ProviderDescriptor &descriptor) - { - // - int listenersCount = ArraySize(mX5OnSignalEventHandlers); - if (listenersCount <= 0) - { - return; - } - - // - for (int i = 0; i < listenersCount; i++) - { - // - TX5OnSignal iListener = mX5OnSignalEventHandlers[i]; - - // - iListener(descriptor); - } - } - - // - // Private ... -private: - // - // Props ... - - // - // Collection of Signal Event Listeners ... - TX5OnSignal mX5OnSignalEventHandlers[]; - - // - // a Collection of X5 Provider Descriptors ... - X5ProviderDescriptor mDescriptors[]; - - // - int CountDescriptors() - { - return ArraySize(mDescriptors); - } - - // - // Tools ... -}; - -// -// Tools ... \ No newline at end of file diff --git a/Experts/x-test.x121ea.mq5 b/Experts/x-test.x121ea.mq5 index 1180ef9a..51acdccc 100644 --- a/Experts/x-test.x121ea.mq5 +++ b/Experts/x-test.x121ea.mq5 @@ -31,18 +31,18 @@ // // Inputs ... -long x121EAMagicNumber = 78692110; // Magic Number -int x121EASlippage = 10; // Slippgae -string x121EASymbols = "EURUSDb"; // Symbols +long x121EAMagicNumber = 78692110; // Magic Number +int x121EASlippage = 10; // Slippgae +string x121EASymbols = "EURUSDb,USDCHFb,GBPUSDb"; // Symbols // bool x121EAAllowLong = true; // Allow Long Trades bool x121EAAllowShort = true; // Allow Short Trades int x121EAManageInterval = 0; // Manager Check Intervals Seconds -int x121EAMaxAllowedPositions = 10; // Max Allowed Positions +int x121EAMaxAllowedPositions = 5; // Max Allowed Positions double x121EAMaxAllowedSpread = 0; // Max Allowed Spred for Opening Trades -double x121EAMinProfitPerTrade = 2; // Min Profit Per Trade based On Volume Factor (Hedge) +double x121EAMinProfitPerTrade = 3; // Min Profit Per Trade based On Volume Factor (Hedge) double x121EAMinProfitPerVolumeFactor = 0.01; // Min Volume Factor for Calculating Profit (Hedge) -double x121EAMaxAllowedDrawdownFactor = 0.005; // Max Allowed Drawdown Factor +double x121EAMaxAllowedDrawdownFactor = 0.003; // Max Allowed Drawdown Factor // double x121EAVolume = 0.01; @@ -288,6 +288,14 @@ void ConfigureDescriptor( X121ProviderDescriptor &iDescriptor // ) { + // + // XHK ... + iDescriptor.inputs.tmInputs.showLine = false; + + // + // XAMA ... + iDescriptor.inputs.amaInputs.showLine = false; + // // XHK ... iDescriptor.inputs.hkInputs.drawHikenAshi = false; @@ -295,8 +303,8 @@ void ConfigureDescriptor( // // XMRB ... - iDescriptor.inputs.mrbInputs.showFastMa = true; - iDescriptor.inputs.mrbInputs.showSlowMa = true; + iDescriptor.inputs.mrbInputs.showFastMa = false; + iDescriptor.inputs.mrbInputs.showSlowMa = false; iDescriptor.inputs.mrbInputs.showRibbon = false; // diff --git a/Experts/x-test.x5121ea.mq5 b/Experts/x-test.x5121ea.mq5 deleted file mode 100644 index 2081bdd9..00000000 --- a/Experts/x-test.x5121ea.mq5 +++ /dev/null @@ -1,1169 +0,0 @@ -/////////////////////////////////////////////////////// -// -// SaherElm IT Center X5121EA MQL5 Expert Advisor -// ------------------------------------------------- -// Name: X5121EA and X121EA -// Description: an Exper Advisor which used RSI and MA -// to Analyse Market ... -// -// Maintainer: -// ------------ -// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) -// -//////////////////////////////////////////////////////x -// -// Global Properties ... -#property copyright "Copyright 2023, SaherElm IT Center" -#property link "https://saherelm.ir" -#property version "1.00" -#property description "SaherElm X5121EA" -#property strict - -// -#define ShortName "X5121EA" - -// -#include "../Classes/x-saherelm.xalert.class.mq5" -#include "../Classes/x-saherelm.xtrade.class.mq5" -#include "../Classes/x-saherelm.x5.provider.class.mq5" -#include "../Classes/x-saherelm.x121.provider.class.mq5" - -// -// a Provider Descriptor which holds -// X5 and X121 Provider at the Same time ... -struct X5121ProviderDescriptor -{ - // - string symbol; // Trading Symbol - ENUM_TIMEFRAMES period; // Trading Timeframe - bool allowLong; // Allow Long Signals - bool allowShort; // Allow Short Signals - double staticVolume; // Static Volume for Positions - ENUM_X5_SIGNAL_PROVIDERS signallers[]; // Allowed Signal Providers - - // - X5ProviderInputs x5Inputs; - XSCX5Provider *x5Provider; - - // - X121ProviderInputs x121Inputs; - XSCX121Provider *x121Provider; - - // - XSignal signal; - X5MarketConditions x5Conditions; - X121MarketConditions x121Conditions; - - // - // Tools ... - - // - // Initial Provider ... - // - bool Init() - { - // - bool result = false; - - // - result = this.Init( - this.symbol, - this.period, - this.signallers, - this.allowLong, - this.allowShort, - this.staticVolume // - ); - - // - return result; - } - - // - bool Init( - ENUM_X5_SIGNAL_PROVIDERS &mSignallers[], // Allowed Signal Providers - bool mAllowLong = true, // Allow Long Signals - bool mAllowShort = true, // Allow Short Signals - double mStaticVolume = 0.01 // Static Volume for Positions - ) - { - // - bool result = false; - - // - result = this.Init( - this.symbol, - this.period, - mSignallers, - mAllowLong, - mAllowShort, - mStaticVolume // - ); - - // - return result; - } - - // - bool Init( - string mSymbol, // Trading Symbol - ENUM_TIMEFRAMES mPeriod, // Trading Timeframe - ENUM_X5_SIGNAL_PROVIDERS &mSignallers[], // Allowed Signal Providers - bool mAllowLong = true, // Allow Long Signals - bool mAllowShort = true, // Allow Short Signals - double mStaticVolume = 0.01 // Static Volume for Positions - ) - { - // - bool result = false; - - // - result = - // - x5Inputs.IsValid() && - IsValid(mSymbol) && - IsValid(mPeriod) && - NotEmpty(mStaticVolume) && - (allowLong || allowShort) && - ArraySize(mSignallers) > 0 - // - ; - if (!result) - { - return result; - } - - // - this.symbol = mSymbol; - this.period = mPeriod; - this.allowLong = mAllowLong; - this.allowShort = mAllowShort; - this.staticVolume = mStaticVolume; - - // - ENUM_X5_SIGNAL_PROVIDERS tmp[]; - Copy( - mSignallers, - tmp // - ); - Copy( - tmp, - this.signallers // - ); - - // - // Instantiate Provider ... - x5Provider = new XSCX5Provider( - this.symbol, - this.period, - this.staticVolume // - ); - - // - // Instantiate Provider ... - x121Provider = new XSCX121Provider( - this.symbol, - this.period, - this.staticVolume // - ); - - // - // Set Long/Short State ... - - // - x5Provider - .SetSignalTypeState( - POSITION_TYPE_BUY, - this.allowLong // - ); - - // - x5Provider - .SetSignalTypeState( - POSITION_TYPE_SELL, - this.allowShort // - ); - - // - x121Provider - .SetSignalTypeState( - POSITION_TYPE_BUY, - this.allowLong // - ); - - // - x121Provider - .SetSignalTypeState( - POSITION_TYPE_SELL, - this.allowShort // - ); - - // - // Enable Required Signallers ... - x5Provider - .SetSignalProviderStates( - this.signallers, - true // - ); - - // - // Now Must to Initialize Provider ... - result = x5Provider.Init( - this.x5Inputs // - ); - if (!result) - { - return result; - } - - // - result = x121Provider.Init( - this.x121Inputs // - ); - - // - return result; - } - - // - // Cleanup ... - void Clean() - { - // - signal.Clean(); - x5Conditions.Clear(); - x121Conditions.Clear(); - } - - // - // Validate ... - bool IsValid(bool validateInputs = true) - { - // - bool result = false; - - // - result = - // - IsValid(symbol) && - IsValid(period) && - NotEmpty(staticVolume) && - (validateInputs - ? x5Inputs.IsValid() && x121Inputs.IsValid() - : true) && - (allowLong || allowShort) && - ArraySize(signallers) > 0 - // - ; - - // - return result; - } - - // - // Check Signal ... - bool HasSignal(int barIndex = 0) - { - // - bool result = false; - - // - result = x5Inputs.IsValid(); - if (!result) - { - return result; - } - - // - result = x121Inputs.IsValid(); - if (!result) - { - return result; - } - - // - // Clear Signal and Conditions ... - Clean(); - - // - result = x5Provider - .HasSignal( - barIndex, - signal, - x5Conditions // - ); - - // - if (result) - { - // - x121Provider - .GetMarketConditions( - x121Conditions, - barIndex // - ); - } - - // - return result; - } - - // - void GenerateScore( - double &bullishScore, - double &bearishScore // - ) - { - // - double x5BullishScore = 5; - double x5BearishScore = 5; - - // - GenerateX5Score( - x5BullishScore, - x5BearishScore // - ); - - // - double x121BullishScore = 5; - double x121BearishScore = 5; - - // - GenerateX121Score( - x121BullishScore, - x121BearishScore // - ); - - // - bullishScore = x5BullishScore + x121BullishScore; - bearishScore = x5BearishScore + x121BearishScore; - } - - // - void GenerateX5Score( - double &bullishScore, - double &bearishScore // - ) - { - // - x5Conditions.GenerateScore( - bullishScore, - bearishScore // - ); - } - - // - void GenerateX121Score( - double &bullishScore, - double &bearishScore // - ) - { - // - x121Conditions.GenerateScore( - bullishScore, - bearishScore // - ); - } - - // - string GenerateSummary( - const bool onlySummary = false, - bool ignoreFalseConditions = true // - ) - { - // - string x5Str = GenerateX5Summary( - onlySummary, - ignoreFalseConditions // - ); - - // - string x121Str = GenerateX121Summary( - onlySummary, - ignoreFalseConditions // - ); - - // - string result = - // - x5Str + "\n" + x121Str - // - ; - - // - return result; - } - - // - string GenerateX5Summary( - const bool onlySummary = false, - bool ignoreFalseConditions = true // - ) - { - return x5Conditions.GenerateSummary( - onlySummary, - 1, - "\n", - ignoreFalseConditions // - ); - } - - // - string GenerateX121Summary( - const bool onlySummary = false, - bool ignoreFalseConditions = true // - ) - { - return x121Conditions.GenerateSummary( - onlySummary, - 1, - 1.1, - 1.2, - 1.6, - 1.8, - "\n", - NULL, - ignoreFalseConditions // - ); - } -}; - -// -// "EURUSDb,USDCHFb,USDJPYb,XAUUSDb" - -// -// Inputs ... -long x5121EAMagicNumber = 78692110; // Magic Number -int x5121EASlippage = 10; // Slippgae -string x5121EASymbols = "EURUSDb"; // Symbols -// -bool x5121EAAllowLong = true; // Allow Long Trades -bool x5121EAAllowShort = true; // Allow Short Trades -int x5121EAManageInterval = 5; // Manager Check Intervals Seconds -int x5121EAMaxAllowedPositions = 15; // Max Allowed Positions -double x5121EAMaxAllowedSpread = 0; // Max Allowed Spred for Opening Trades -double x5121EAMinProfitPerTrade = 0; // Min Profit Per Trade based On Volume Factor (Hedge) -double x5121EAMinProfitPerVolumeFactor = 0; // Min Volume Factor for Calculating Profit (Hedge) -double x5121EAMaxAllowedDrawdownFactor = 0; // Max Allowed Drawdown Factor -// -double x5121EAVolume = 0.01; -// -bool x5121EAEnableAlerts = true; // Enable Alerts -bool x5121EALogAlerts = true; // Log Alerts -bool x5121EATerminalAlerts = false; // Terminal Alerts -bool x5121EAMailAlerts = false; // Mail Alerts -bool x5121EAPushAlerts = false; // Push Alerts - -// -// Vars ... -string x5121EASymbol; -ENUM_TIMEFRAMES x5121EAPeriod; - -// -MqlTick x5121EATick; - -// -// Trade Class Instance ... -XSCTrade *x5121EATrader; -XSCAlert *x5121EAAlert; - -// -// Providers ... -X5121ProviderDescriptor x5121EAProviders[]; - -// -// Event Handlers ... - -// -// Initialization ... -int OnInit() -{ - // - if (x5121EASymbol == NULL || StringLen(x5121EASymbol) <= 0) - { - x5121EASymbol = _Symbol; - } - - // - if (x5121EAPeriod == NULL) - { - x5121EAPeriod = _Period; - } - - // - // Validate Inputs ... - if (!X5121EAValidateInputs()) - { - return INIT_PARAMETERS_INCORRECT; - } - - // - // Initial EA ... - if (!InitialEA()) - { - return INIT_PARAMETERS_INCORRECT; - } - - // - // TesterHideIndicators(true); - - // - // Init Succeed ... - return INIT_SUCCEEDED; -} - -// -// DeInitialization ... -void OnDeinit(const int reason) -{ - // - // REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function - // REASON_REMOVE 1 Program removed from a chart - // REASON_RECOMPILE 2 Program recompiled - // REASON_CHARTCHANGE 3 A symbol or a chart period is changed - // REASON_CHARTCLOSE 4 Chart closed - // REASON_PARAMETERS 5 Inputs changed by a user - // REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings - // REASON_TEMPLATE 7 Another chart template applied - // REASON_INITFAILED 8 The OnInit() handler returned a non-zero value - // REASON_CLOSE 9 Terminal closed - - // - // De Initialize X5121EA Providers ... -} - -// -// On Tick Handler ... -void OnTick() -{ - // - // Reading Tick ... - if (!SymbolInfoTick(x5121EASymbol, x5121EATick)) - { - return; - } - - // - // Draw ... - HandleOnDraw(); - - // - // Check Trade Events ... - XOnTradeHandlerState tState; - x5121EATrader.HandleOnTradeEvent(tState); - - // - // First Check For Any Guard Actions ... - // then Handle Guards if Provided ... - XGuard guards[]; - bool hasGuard = CheckForGuard(guards); - if (hasGuard) - { - // - // TODO: Complete this ... - // DoGuards(guards); - } - - // - // Second Check for Position Management or Equity Management - // Actions like Supports or etc ... - bool isIgnored = HandleStateManagement(); - if (isIgnored) - { - return; - } - - // - // Second Check For Signals ... - // then Execute Signals if Provided ... - XSignal signals[]; - int signalsCount = RequestForSignal(signals); - if (signalsCount <= 0) - { - return; - } - - // - // Execute Signals ... - HandleSignalsExecution(signals); -} - -// -// Custom Functions ... - -// -// Validate Variables nd Inputs ... -bool X5121EAValidateInputs() -{ - // - bool result = false; - - // - result = - // - x5121EASlippage > 0 && - x5121EAMagicNumber > 0 - // - ; - - // - return result; -} - -// -// Initialize Specific Providers ... -bool InitialEA() -{ - // - bool result = false; - - // - // Here We Have to Initial 4 instance of X5Provider ... - // - EURUSD/M5; - // - USDCHF/M5; - // - USDJPY/M5; - // - XAUUSD/M5; - - // - result = IsValid(x5121EASymbols); - if (!result) - { - return result; - } - - // - string symbols[]; - int symbolsCount = SplitContent( - symbols, - x5121EASymbols); - result = symbolsCount > 0; - if (!result) - { - return result; - } - - // - // Instance XSCTrade Class ... - x5121EATrader = new XSCTrade( - x5121EASlippage, - x5121EAMagicNumber, - x5121EAManageInterval, - x5121EAMaxAllowedSpread, - x5121EAMaxAllowedPositions, - x5121EAMaxAllowedDrawdownFactor - // - ); - - // - // Instantiate Alert Class ... - x5121EAAlert = new XSCAlert( - "X5121EA", - x5121EAEnableAlerts, - x5121EALogAlerts, - x5121EATerminalAlerts, - x5121EAMailAlerts, - x5121EAPushAlerts - // - ); - - // - // Define Signallers ... - ENUM_X5_SIGNAL_PROVIDERS signallers[]; - GetAllX5SignalProviders(signallers); - - // - Clean(x5121EAProviders); - - // - // Prepare Providers and Add them into mX5121EA class ... - for (int i = 0; i < symbolsCount; i++) - { - // - // Define Structure ... - X5121ProviderDescriptor iDescriptor; - - // - iDescriptor.symbol = symbols[i]; - iDescriptor.period = PERIOD_M5; - iDescriptor.staticVolume = x5121EAVolume; - iDescriptor.allowLong = x5121EAAllowLong; - iDescriptor.allowShort = x5121EAAllowShort; - Copy( - signallers, - iDescriptor.signallers); - - // - // Set Inputs to Default ... - iDescriptor.x5Inputs.Default(); - iDescriptor.x121Inputs.Default(); - - // - // X121 Inputs ... - // - // Prepare Input Requirements ... - - // - // XMC ... - iDescriptor.x121Inputs.mcInputs.showFastMa = false; - iDescriptor.x121Inputs.mcInputs.showSlowMa = false; - iDescriptor.x121Inputs.mcInputs.showVerifierMa = false; - - // - // XICH ... - iDescriptor.x121Inputs.ichInputs.showKumo = false; - iDescriptor.x121Inputs.ichInputs.showKijunSen = false; - iDescriptor.x121Inputs.ichInputs.showTenkanSen = false; - iDescriptor.x121Inputs.ichInputs.showChikouSpan = false; - iDescriptor.x121Inputs.ichInputs.showSenkouSpanA = false; - iDescriptor.x121Inputs.ichInputs.showSenkouSpanB = false; - iDescriptor.x121Inputs.ichInputs.showKijunSenPlus = false; - iDescriptor.x121Inputs.ichInputs.showKijunSenNegative = false; - - // - // XSTR ... - iDescriptor.x121Inputs.cheInputs.showLongExit1Line = false; - iDescriptor.x121Inputs.cheInputs.showShortExit1Line = false; - iDescriptor.x121Inputs.cheInputs.showLongExit2Line = false; - iDescriptor.x121Inputs.cheInputs.showShortExit2Line = false; - - // - // XPV ... - iDescriptor.x121Inputs.pvInputs.showPeaksAndVales = true; - iDescriptor.x121Inputs.pvInputs.showLevels = false; - iDescriptor.x121Inputs.pvInputs.showConsolidations = false; - iDescriptor.x121Inputs.pvInputs.showFibo1Levels = false; - iDescriptor.x121Inputs.pvInputs.showFibo2Levels = false; - iDescriptor.x121Inputs.pvInputs.showFibo3Levels = true; - iDescriptor.x121Inputs.pvInputs.showFibo4Levels = false; - iDescriptor.x121Inputs.pvInputs.showFibo5Levels = false; - - // - // XZG ... - iDescriptor.x121Inputs.zgInputs.showZigZag = false; - iDescriptor.x121Inputs.zgInputs.showPeaksAndVales = false; - - // - // XDON ... - iDescriptor.x121Inputs.donInputs.showOpen = true; - iDescriptor.x121Inputs.donInputs.showHigh = true; - iDescriptor.x121Inputs.donInputs.showClose = true; - iDescriptor.x121Inputs.donInputs.showLow = true; - - // - // XSTR ... - iDescriptor.x121Inputs.strInputs.showTrends = true; - iDescriptor.x121Inputs.strInputs.fillTrends = false; - - // - iDescriptor.x121Inputs.symbol = iDescriptor.symbol; - iDescriptor.x121Inputs.period = iDescriptor.period; - - // - // Short MArket ... - iDescriptor.x121Inputs.sMarketPeriod = NULL; - iDescriptor.x121Inputs.sMarketMethod = X_PERIOD_AUTO; - - // - // Medium Market ... - iDescriptor.x121Inputs.mMarketPeriod = NULL; - iDescriptor.x121Inputs.mMarketMethod = X_PERIOD_AUTO; - - // - // Long Market ... - iDescriptor.x121Inputs.lMarketPeriod = NULL; - iDescriptor.x121Inputs.lMarketMethod = X_PERIOD_AUTO; - - // - int fontSize = 12; - double fontAngel = 90; - string fontName = "Arial"; - ENUM_ANCHOR_POINT fontAnchor = ANCHOR_LEFT_UPPER; - - // - // Hind Market ... - iDescriptor.x121Inputs.hMarketPeriod = NULL; - iDescriptor.x121Inputs.hMarketMethod = X_PERIOD_AUTO; - iDescriptor.x121Inputs.hMarketInputs.drawLabels = false; - iDescriptor.x121Inputs.hMarketInputs.drawCBar = true; - iDescriptor.x121Inputs.hMarketInputs.drawPBar = true; - iDescriptor.x121Inputs.hMarketInputs.drawCBarMid = true; - iDescriptor.x121Inputs.hMarketInputs.drawPBarMid = true; - iDescriptor.x121Inputs.hMarketInputs.cBarDrawSpecs.Default(); - iDescriptor.x121Inputs.hMarketInputs.pBarDrawSpecs.Default(); - - // - iDescriptor.x121Inputs.hMarketInputs.cBarDrawSpecs.openStyle.Label( - "C Hind Open", - iDescriptor.x121Inputs.hMarketInputs.cBarDrawSpecs.openStyle.clr, - fontName, - fontSize, - fontAnchor, - fontAngel // - ); - iDescriptor.x121Inputs.hMarketInputs.cBarDrawSpecs.highStyle.Label( - "C Hind High", - iDescriptor.x121Inputs.hMarketInputs.cBarDrawSpecs.highStyle.clr, - fontName, - fontSize, - fontAnchor, - fontAngel // - ); - iDescriptor.x121Inputs.hMarketInputs.cBarDrawSpecs.closeStyle.Label( - "C Hind Close", - iDescriptor.x121Inputs.hMarketInputs.cBarDrawSpecs.closeStyle.clr, - fontName, - fontSize, - fontAnchor, - fontAngel // - ); - iDescriptor.x121Inputs.hMarketInputs.cBarDrawSpecs.lowStyle.Label( - "C Hind Low", - iDescriptor.x121Inputs.hMarketInputs.cBarDrawSpecs.lowStyle.clr, - fontName, - fontSize, - fontAnchor, - fontAngel // - ); - - // - iDescriptor.x121Inputs.hMarketInputs.pBarDrawSpecs.openStyle.Label( - "P Hind Open", - iDescriptor.x121Inputs.hMarketInputs.pBarDrawSpecs.openStyle.clr, - fontName, - fontSize, - fontAnchor, - fontAngel // - ); - iDescriptor.x121Inputs.hMarketInputs.pBarDrawSpecs.highStyle.Label( - "P Hind High", - iDescriptor.x121Inputs.hMarketInputs.pBarDrawSpecs.highStyle.clr, - fontName, - fontSize, - fontAnchor, - fontAngel // - ); - iDescriptor.x121Inputs.hMarketInputs.pBarDrawSpecs.closeStyle.Label( - "P Hind Close", - iDescriptor.x121Inputs.hMarketInputs.pBarDrawSpecs.closeStyle.clr, - fontName, - fontSize, - fontAnchor, - fontAngel // - ); - iDescriptor.x121Inputs.hMarketInputs.pBarDrawSpecs.lowStyle.Label( - "P Hind Low", - iDescriptor.x121Inputs.hMarketInputs.pBarDrawSpecs.lowStyle.clr, - fontName, - fontSize, - fontAnchor, - fontAngel // - ); - - iDescriptor.x121Inputs.hMarketInputs.cBarMidDrawSpecs.clr = clrYellow; - iDescriptor.x121Inputs.hMarketInputs.cBarMidDrawSpecs.Label( - "C Hind Mid", - clrYellow, - fontName, - fontSize, - fontAnchor, - fontAngel // - ); - iDescriptor.x121Inputs.hMarketInputs.pBarMidDrawSpecs.clr = clrYellow; - iDescriptor.x121Inputs.hMarketInputs.pBarMidDrawSpecs.Label( - "P Hind Mid", - clrYellow, - fontName, - fontSize, - fontAnchor, - fontAngel // - ); - - // - // Validate Inputs ... - bool isX5InputsValid = iDescriptor.x5Inputs.IsValid(); - if (!isX5InputsValid) - { - break; - } - - // - // Init X121 Inputs ... - bool isX121InputsInit = iDescriptor.x121Inputs.Init(); - if (!isX121InputsInit) - { - break; - } - - // - // Initialize ... - - // - bool isDescriptorInitialized = iDescriptor.Init(); - if (!isDescriptorInitialized) - { - break; - } - - // - AddRef( - iDescriptor, - x5121EAProviders // - ); - - // - } - - // - result = ArraySize(x5121EAProviders) == symbolsCount; - - // - return result; -} - -// -void HandleOnDraw() {} - -// -bool HandleStateManagement() -{ - return false; -} - -// -bool CheckForGuard(XGuard &guards[]) -{ - return false; -} - -// -int RequestForSignal( - XSignal &signals[] // Holds Signals ... -) -{ - // - int result = 0; - - // - Clean(signals); - - // - int descriptorsCount = ArraySize(x5121EAProviders); - if (descriptorsCount <= 0) - { - return result; - } - - // - for (int i = 0; i < descriptorsCount; i++) - { - // - X5121ProviderDescriptor iDescriptor = x5121EAProviders[i]; - - // - iDescriptor.x5Provider.GetMarketConditions( - iDescriptor.x5Conditions // - ); - - // - iDescriptor.x121Provider.GetMarketConditions( - iDescriptor.x121Conditions // - ); - - // - X5MarketConditions x5Conditions = iDescriptor.x5Conditions; - X121MarketConditions x121Conditions = iDescriptor.x121Conditions; - - // - // Check For Long ... - bool hasLong = - // - (x121Conditions.hMarketConditions.isTrendSwitchedToBullish && - (x121Conditions.lMarketConditions.isTrendBullish && - x121Conditions.mMarketConditions.isTrendBullish && - x121Conditions.sMarketConditions.isTrendBullish && - x121Conditions.cMarketConditions.isTrendBullish)) - // - || - // - (x121Conditions.lMarketConditions.isTrendSwitchedToBullish && - (x121Conditions.hMarketConditions.isTrendBullish && - x121Conditions.mMarketConditions.isTrendBullish && - x121Conditions.sMarketConditions.isTrendBullish && - x121Conditions.cMarketConditions.isTrendBullish)) - // - || - // - (x121Conditions.mMarketConditions.isTrendSwitchedToBullish && - (x121Conditions.hMarketConditions.isTrendBullish && - x121Conditions.lMarketConditions.isTrendBullish && - x121Conditions.sMarketConditions.isTrendBullish && - x121Conditions.cMarketConditions.isTrendBullish)) - // - || - // - (x121Conditions.sMarketConditions.isTrendSwitchedToBullish && - (x121Conditions.hMarketConditions.isTrendBullish && - x121Conditions.lMarketConditions.isTrendBullish && - x121Conditions.mMarketConditions.isTrendBullish && - x121Conditions.cMarketConditions.isTrendBullish)) - // - || - // - (x121Conditions.cMarketConditions.isTrendSwitchedToBullish && - (x121Conditions.hMarketConditions.isTrendBullish && - x121Conditions.lMarketConditions.isTrendBullish && - x121Conditions.mMarketConditions.isTrendBullish && - x121Conditions.sMarketConditions.isTrendBullish)) - // - ; - - // - // Check For Short ... - bool hasShort = - // - false - // - ; - - if (hasLong) - { - Print(""); - } - - // - // bool iHasSignal = iDescriptor.HasSignal(0); - // if (iHasSignal) - // { - // // - // AddRef( - // iDescriptor.signal, - // signals // - // ); - - // // // - // // string conditionsStr = iDescriptor.GenerateSummary(); - // // Print(conditionsStr); - - // // - // double bullScore = 0; - // double bearScore = 0; - // iDescriptor.GenerateScore( - // bullScore, - // bearScore // - // ); - - // // - // Print(" "); - // Print((IsLong(iDescriptor.signal.type) ? "Long" : "Short")); - // Print(iDescriptor.signal.symbol, ",", ToString(iDescriptor.signal.period), ",", iDescriptor.signal.provider); - // Print("========================"); - // Print("bullScore: ", bullScore); - // Print("bearScore: ", bearScore); - - // // - // Print(""); - - // // - // Print(iDescriptor.GenerateX121Summary()); - // } - } - - // - result = ArraySize(signals); - - // - return result; -} - -// -void HandleSignalsExecution(XSignal &signals[]) -{ - // - int signalsCount = ArraySize(signals); - if (signalsCount <= 0) - { - return; - } - - // - // Filter Signals Based on their Types ... - XSignal filteredSignals[]; - - // - // Try to Filter Signals ... - for (int i = 0; i < signalsCount; i++) - { - // - XSignal iSignal = signals[i]; - - // - bool isLong = IsLong(iSignal.type); - - // - if ((isLong && !x5121EAAllowLong) || (!isLong && !x5121EAAllowShort)) - { - continue; - } - - // - AddRef( - iSignal, - filteredSignals // - ); - } - - // - int filteredSignalsCount = ArraySize(filteredSignals); - if (filteredSignalsCount <= 0) - { - return; - } - - // - // Try to Execute Signals ... - ENUM_X_SIGNAL_EXECUTION_RESULT reasons[]; - int executedSignalsCount = x5121EATrader.ExecuteSignals( - filteredSignals, - reasons - // - ); - - // - string message = NULL; - if (executedSignalsCount == 0) - { - // - message = "(" + ToString(filteredSignalsCount) + ") Signals Execution Failed ..."; - - // - for (int j = 0; j < ArraySize(reasons); j++) - { - // - string iReason = ToString(reasons[j]); - - // - // ToString(GetSpread(filteredSignals[j].symbol)) + "," - message += "\n" + ToString(j) + ": " + iReason; - } - } - else if (executedSignalsCount < filteredSignalsCount) - { - // - int diff = filteredSignalsCount - executedSignalsCount; - - // - message = "Failed to Execute (" + ToString(diff) + ") Signals ..."; - } - else if (executedSignalsCount == filteredSignalsCount) - { - message = "(" + ToString(executedSignalsCount) + ") Signals Executed Successfully ..."; - } - - // - if (IsValid(message)) - { - x5121EAAlert.Alert(message); - } -} - -// \ No newline at end of file diff --git a/Experts/x-test.x5ea.mq5 b/Experts/x-test.x5ea.mq5 deleted file mode 100644 index cae3ad7f..00000000 --- a/Experts/x-test.x5ea.mq5 +++ /dev/null @@ -1,252 +0,0 @@ -/////////////////////////////////////////////////////// -// -// SaherElm IT Center X5EA MQL5 Expert Advisor -// ------------------------------------------------- -// Name: X5EA -// Description: an Exper Advisor which used RSI and MA -// to Analyse Market ... -// -// Maintainer: -// ------------ -// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) -// -//////////////////////////////////////////////////////x -// -// Global Properties ... -#property copyright "Copyright 2023, SaherElm IT Center" -#property link "https://saherelm.ir" -#property version "1.00" -#property description "SaherElm X5EA" -#property strict - -// -#define ShortName "X5EA" - -// -#include "../Classes/x-saherelm.x5.xea.class.mq5" - -// -// "EURUSDb,USDCHFb,USDJPYb,XAUUSDb" - -// -// Inputs ... -long x5EAMagicNumber = 78692110; // Magic Number -int x5EASlippage = 10; // Slippgae -string x5EASymbols = "EURUSDb,USDCHFb,USDJPYb,XAUUSDb"; // Symbols -// -bool x5EAAllowLong = true; // Allow Long Trades -bool x5EAAllowShort = true; // Allow Short Trades -int x5EAManageInterval = 5; // Manager Check Intervals Seconds -int x5EAMaxAllowedPositions = 15; // Max Allowed Positions -double x5EAMaxAllowedSpread = 0; // Max Allowed Spred for Opening Trades -double x5EAMinProfitPerTrade = 0; // Min Profit Per Trade based On Volume Factor (Hedge) -double x5EAMinProfitPerVolumeFactor = 0; // Min Volume Factor for Calculating Profit (Hedge) -double x5EAMaxAllowedDrawdownFactor = 0; // Max Allowed Drawdown Factor -// -double x5EAVolume = 0.01; - -// -// Vars ... -string x5EASymbol; -ENUM_TIMEFRAMES x5EAPeriod; - -// -MqlTick x5EATick; - -// -// X5EA ... -XSCX5EA *mX5EA; - -// -// Event Handlers ... - -// -// Initialization ... -int OnInit() -{ - // - if (x5EASymbol == NULL || StringLen(x5EASymbol) <= 0) - { - x5EASymbol = _Symbol; - } - - // - if (x5EAPeriod == NULL) - { - x5EAPeriod = _Period; - } - - // - // Validate Inputs ... - if (!X5EAValidateInputs()) - { - return INIT_PARAMETERS_INCORRECT; - } - - // - // Initial EA ... - if (!InitialEA()) - { - return INIT_PARAMETERS_INCORRECT; - } - - // - TesterHideIndicators(true); - - // - // Init Succeed ... - return INIT_SUCCEEDED; -} - -// -// DeInitialization ... -void OnDeinit(const int reason) -{ - // - // REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function - // REASON_REMOVE 1 Program removed from a chart - // REASON_RECOMPILE 2 Program recompiled - // REASON_CHARTCHANGE 3 A symbol or a chart period is changed - // REASON_CHARTCLOSE 4 Chart closed - // REASON_PARAMETERS 5 Inputs changed by a user - // REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings - // REASON_TEMPLATE 7 Another chart template applied - // REASON_INITFAILED 8 The OnInit() handler returned a non-zero value - // REASON_CLOSE 9 Terminal closed - - // - // De Initialize X5EA Providers ... -} - -// -// On Tick Handler ... -void OnTick() -{ - // - // Reading Tick ... - if (!SymbolInfoTick(x5EASymbol, x5EATick)) - { - return; - } - - // - mX5EA.OnTick(); -} - -// -// Custom Functions ... - -// -// Validate Variables nd Inputs ... -bool X5EAValidateInputs() -{ - // - bool result = false; - - // - result = - // - x5EASlippage > 0 && - x5EAMagicNumber > 0 - // - ; - - // - return result; -} - -// -// Initialize Specific Providers ... -bool InitialEA() -{ - // - bool result = false; - - // - // Here We Have to Initial 4 instance of X5Provider ... - // - EURUSD/M5; - // - USDCHF/M5; - // - USDJPY/M5; - // - XAUUSD/M5; - - // - result = IsValid(x5EASymbols); - if (!result) - { - return result; - } - - // - string symbols[]; - int symbolsCount = SplitContent( - symbols, - x5EASymbols); - result = symbolsCount > 0; - if (!result) - { - return result; - } - - // - // Define Signallers ... - ENUM_X5_SIGNAL_PROVIDERS signallers[]; - GetAllX5SignalProviders(signallers); - - // - // Instantiate X5EA Class ... - mX5EA = new XSCX5EA( - x5EASlippage, // Slippgae - x5EAMagicNumber, // Magic Number - x5EAManageInterval, // Manager Check Intervals Seconds - x5EAMaxAllowedSpread, // Max Allowed Spred for Opening Trades - x5EAMaxAllowedPositions, // Max Allowed Positions - x5EAMaxAllowedDrawdownFactor, // Max Allowed Drawdown Factor - x5EAAllowLong, // Allow Long Trades - x5EAAllowShort, // Allow Short Trades - x5EAMinProfitPerTrade, // Min Profit Per Trade based On Volume Factor (Hedge) - x5EAMinProfitPerVolumeFactor // Min Volume Factor for Calculating Profit (Hedge) - ); - - // - // Prepare Providers and Add them into mX5EA class ... - for (int i = 0; i < symbolsCount; i++) - { - // - // Define Structure ... - X5ProviderDescriptor iDescriptor; - - // - iDescriptor.symbol = symbols[i]; - iDescriptor.period = PERIOD_M5; - iDescriptor.staticVolume = x5EAVolume; - iDescriptor.allowLong = x5EAAllowLong; - iDescriptor.allowShort = x5EAAllowShort; - Copy( - signallers, - iDescriptor.signallers); - - // - // Set Inputs to Default ... - iDescriptor.inputs.Default(); - - // - // Validate Inputs ... - bool isInputsValid = iDescriptor.inputs.IsValid(); - if (!isInputsValid) - { - continue; - } - - // - result = mX5EA.AddProvider(iDescriptor); - if (!result) - { - break; - } - } - - // - return result; -} - -// \ No newline at end of file diff --git a/Indicators/x-saherelm.xchlh.mq5 b/Indicators/x-saherelm.xchlh.mq5 index 864b6335..3df87f02 100644 --- a/Indicators/x-saherelm.xchlh.mq5 +++ b/Indicators/x-saherelm.xchlh.mq5 @@ -118,11 +118,13 @@ input bool scDrawLL = true; // Draw Lowest Low // // START Buffers ... // -#property indicator_separate_window +// #property indicator_separate_window +#property indicator_chart_window // #property indicator_buffers 7 -#property indicator_plots 6 +// #property indicator_plots 6 +#property indicator_plots 0 // // LC ... @@ -412,26 +414,28 @@ void LCDefineBuffers() string lcHHBufferLabel = ShortName + " LC HH (" + (string)lcLength + ")"; ENUM_DRAW_TYPE lcHHDrawType = lcDrawHH ? lcDrawType : DRAW_NONE; ArraySetAsSeries(lcHHBuffer, true); - SetIndexBuffer(lcHHBufferIndex, lcHHBuffer, INDICATOR_DATA); - PlotIndexSetInteger(lcHHBufferIndex, PLOT_DRAW_BEGIN, lcLength); - PlotIndexSetString(lcHHBufferIndex, PLOT_LABEL, lcHHBufferLabel); - PlotIndexSetInteger(lcHHBufferIndex, PLOT_LINE_COLOR, lcHHColor); - PlotIndexSetInteger(lcHHBufferIndex, PLOT_LINE_STYLE, lcDrawStyle); - PlotIndexSetInteger(lcHHBufferIndex, PLOT_LINE_WIDTH, lcDrawWidth); - PlotIndexSetInteger(lcHHBufferIndex, PLOT_DRAW_TYPE, lcHHDrawType); + SetIndexBuffer(lcHHBufferIndex, lcHHBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(lcHHBufferIndex, lcHHBuffer, INDICATOR_DATA); + // PlotIndexSetInteger(lcHHBufferIndex, PLOT_DRAW_BEGIN, lcLength); + // PlotIndexSetString(lcHHBufferIndex, PLOT_LABEL, lcHHBufferLabel); + // PlotIndexSetInteger(lcHHBufferIndex, PLOT_LINE_COLOR, lcHHColor); + // PlotIndexSetInteger(lcHHBufferIndex, PLOT_LINE_STYLE, lcDrawStyle); + // PlotIndexSetInteger(lcHHBufferIndex, PLOT_LINE_WIDTH, lcDrawWidth); + // PlotIndexSetInteger(lcHHBufferIndex, PLOT_DRAW_TYPE, lcHHDrawType); // // LC LL Buffer ... string lcLLBufferLabel = ShortName + " LC LL (" + (string)lcLength + ")"; ENUM_DRAW_TYPE lcLLDrawType = lcDrawLL ? lcDrawType : DRAW_NONE; ArraySetAsSeries(lcLLBuffer, true); - SetIndexBuffer(lcLLBufferIndex, lcLLBuffer, INDICATOR_DATA); - PlotIndexSetInteger(lcLLBufferIndex, PLOT_DRAW_BEGIN, lcLength); - PlotIndexSetString(lcLLBufferIndex, PLOT_LABEL, lcLLBufferLabel); - PlotIndexSetInteger(lcLLBufferIndex, PLOT_LINE_COLOR, lcLLColor); - PlotIndexSetInteger(lcLLBufferIndex, PLOT_LINE_STYLE, lcDrawStyle); - PlotIndexSetInteger(lcLLBufferIndex, PLOT_LINE_WIDTH, lcDrawWidth); - PlotIndexSetInteger(lcLLBufferIndex, PLOT_DRAW_TYPE, lcLLDrawType); + SetIndexBuffer(lcLLBufferIndex, lcLLBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(lcLLBufferIndex, lcLLBuffer, INDICATOR_DATA); + // PlotIndexSetInteger(lcLLBufferIndex, PLOT_DRAW_BEGIN, lcLength); + // PlotIndexSetString(lcLLBufferIndex, PLOT_LABEL, lcLLBufferLabel); + // PlotIndexSetInteger(lcLLBufferIndex, PLOT_LINE_COLOR, lcLLColor); + // PlotIndexSetInteger(lcLLBufferIndex, PLOT_LINE_STYLE, lcDrawStyle); + // PlotIndexSetInteger(lcLLBufferIndex, PLOT_LINE_WIDTH, lcDrawWidth); + // PlotIndexSetInteger(lcLLBufferIndex, PLOT_DRAW_TYPE, lcLLDrawType); } // @@ -443,26 +447,28 @@ void MCDefineBuffers() string mcHHBufferLabel = ShortName + " MC HH (" + (string)mcLength + ")"; ENUM_DRAW_TYPE mcHHDrawType = mcDrawHH ? lcDrawType : DRAW_NONE; ArraySetAsSeries(mcHHBuffer, true); - SetIndexBuffer(mcHHBufferIndex, mcHHBuffer, INDICATOR_DATA); - PlotIndexSetInteger(mcHHBufferIndex, PLOT_DRAW_BEGIN, mcLength); - PlotIndexSetString(mcHHBufferIndex, PLOT_LABEL, mcHHBufferLabel); - PlotIndexSetInteger(mcHHBufferIndex, PLOT_LINE_COLOR, mcHHColor); - PlotIndexSetInteger(mcHHBufferIndex, PLOT_LINE_STYLE, mcDrawStyle); - PlotIndexSetInteger(mcHHBufferIndex, PLOT_LINE_WIDTH, mcDrawWidth); - PlotIndexSetInteger(mcHHBufferIndex, PLOT_DRAW_TYPE, mcHHDrawType); + SetIndexBuffer(mcHHBufferIndex, mcHHBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(mcHHBufferIndex, mcHHBuffer, INDICATOR_DATA); + // PlotIndexSetInteger(mcHHBufferIndex, PLOT_DRAW_BEGIN, mcLength); + // PlotIndexSetString(mcHHBufferIndex, PLOT_LABEL, mcHHBufferLabel); + // PlotIndexSetInteger(mcHHBufferIndex, PLOT_LINE_COLOR, mcHHColor); + // PlotIndexSetInteger(mcHHBufferIndex, PLOT_LINE_STYLE, mcDrawStyle); + // PlotIndexSetInteger(mcHHBufferIndex, PLOT_LINE_WIDTH, mcDrawWidth); + // PlotIndexSetInteger(mcHHBufferIndex, PLOT_DRAW_TYPE, mcHHDrawType); // // MC LL Buffer ... string mcLLBufferLabel = ShortName + " MC LL (" + (string)mcLength + ")"; ENUM_DRAW_TYPE mcLLDrawType = mcDrawLL ? lcDrawType : DRAW_NONE; ArraySetAsSeries(mcLLBuffer, true); - SetIndexBuffer(mcLLBufferIndex, mcLLBuffer, INDICATOR_DATA); - PlotIndexSetInteger(mcLLBufferIndex, PLOT_DRAW_BEGIN, mcLength); - PlotIndexSetString(mcLLBufferIndex, PLOT_LABEL, mcLLBufferLabel); - PlotIndexSetInteger(mcLLBufferIndex, PLOT_LINE_COLOR, mcLLColor); - PlotIndexSetInteger(mcLLBufferIndex, PLOT_LINE_STYLE, mcDrawStyle); - PlotIndexSetInteger(mcLLBufferIndex, PLOT_LINE_WIDTH, mcDrawWidth); - PlotIndexSetInteger(mcLLBufferIndex, PLOT_DRAW_TYPE, mcLLDrawType); + SetIndexBuffer(mcLLBufferIndex, mcLLBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(mcLLBufferIndex, mcLLBuffer, INDICATOR_DATA); + // PlotIndexSetInteger(mcLLBufferIndex, PLOT_DRAW_BEGIN, mcLength); + // PlotIndexSetString(mcLLBufferIndex, PLOT_LABEL, mcLLBufferLabel); + // PlotIndexSetInteger(mcLLBufferIndex, PLOT_LINE_COLOR, mcLLColor); + // PlotIndexSetInteger(mcLLBufferIndex, PLOT_LINE_STYLE, mcDrawStyle); + // PlotIndexSetInteger(mcLLBufferIndex, PLOT_LINE_WIDTH, mcDrawWidth); + // PlotIndexSetInteger(mcLLBufferIndex, PLOT_DRAW_TYPE, mcLLDrawType); } // @@ -474,26 +480,28 @@ void SCDefineBuffers() string scHHBufferLabel = ShortName + " SC HH (" + (string)scLength + ")"; ENUM_DRAW_TYPE scHHDrawType = scDrawHH ? lcDrawType : DRAW_NONE; ArraySetAsSeries(scHHBuffer, true); - SetIndexBuffer(scHHBufferIndex, scHHBuffer, INDICATOR_DATA); - PlotIndexSetInteger(scHHBufferIndex, PLOT_DRAW_BEGIN, scLength); - PlotIndexSetString(scHHBufferIndex, PLOT_LABEL, scHHBufferLabel); - PlotIndexSetInteger(scHHBufferIndex, PLOT_LINE_COLOR, scHHColor); - PlotIndexSetInteger(scHHBufferIndex, PLOT_LINE_STYLE, scDrawStyle); - PlotIndexSetInteger(scHHBufferIndex, PLOT_LINE_WIDTH, scDrawWidth); - PlotIndexSetInteger(scHHBufferIndex, PLOT_DRAW_TYPE, scHHDrawType); + SetIndexBuffer(scHHBufferIndex, scHHBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(scHHBufferIndex, scHHBuffer, INDICATOR_DATA); + // PlotIndexSetInteger(scHHBufferIndex, PLOT_DRAW_BEGIN, scLength); + // PlotIndexSetString(scHHBufferIndex, PLOT_LABEL, scHHBufferLabel); + // PlotIndexSetInteger(scHHBufferIndex, PLOT_LINE_COLOR, scHHColor); + // PlotIndexSetInteger(scHHBufferIndex, PLOT_LINE_STYLE, scDrawStyle); + // PlotIndexSetInteger(scHHBufferIndex, PLOT_LINE_WIDTH, scDrawWidth); + // PlotIndexSetInteger(scHHBufferIndex, PLOT_DRAW_TYPE, scHHDrawType); // // SC LL Buffer ... string scLLBufferLabel = ShortName + " SC LL (" + (string)scLength + ")"; ENUM_DRAW_TYPE scLLDrawType = scDrawLL ? lcDrawType : DRAW_NONE; ArraySetAsSeries(scLLBuffer, true); - SetIndexBuffer(scLLBufferIndex, scLLBuffer, INDICATOR_DATA); - PlotIndexSetInteger(scLLBufferIndex, PLOT_DRAW_BEGIN, scLength); - PlotIndexSetString(scLLBufferIndex, PLOT_LABEL, scLLBufferLabel); - PlotIndexSetInteger(scLLBufferIndex, PLOT_LINE_COLOR, scLLColor); - PlotIndexSetInteger(scLLBufferIndex, PLOT_LINE_STYLE, scDrawStyle); - PlotIndexSetInteger(scLLBufferIndex, PLOT_LINE_WIDTH, scDrawWidth); - PlotIndexSetInteger(scLLBufferIndex, PLOT_DRAW_TYPE, scLLDrawType); + SetIndexBuffer(scLLBufferIndex, scLLBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(scLLBufferIndex, scLLBuffer, INDICATOR_DATA); + // PlotIndexSetInteger(scLLBufferIndex, PLOT_DRAW_BEGIN, scLength); + // PlotIndexSetString(scLLBufferIndex, PLOT_LABEL, scLLBufferLabel); + // PlotIndexSetInteger(scLLBufferIndex, PLOT_LINE_COLOR, scLLColor); + // PlotIndexSetInteger(scLLBufferIndex, PLOT_LINE_STYLE, scDrawStyle); + // PlotIndexSetInteger(scLLBufferIndex, PLOT_LINE_WIDTH, scDrawWidth); + // PlotIndexSetInteger(scLLBufferIndex, PLOT_DRAW_TYPE, scLLDrawType); } // diff --git a/Indicators/x-saherelm.xchma.mq5 b/Indicators/x-saherelm.xchma.mq5 index efc75247..e59bc430 100644 --- a/Indicators/x-saherelm.xchma.mq5 +++ b/Indicators/x-saherelm.xchma.mq5 @@ -121,11 +121,13 @@ input bool scDrawCrosses = false; // Draw Cross Lines // // START Buffers ... // -#property indicator_separate_window +// #property indicator_separate_window +#property indicator_chart_window // #property indicator_buffers 7 -#property indicator_plots 6 +// #property indicator_plots 6 +#property indicator_plots 0 // // LC ... @@ -519,26 +521,28 @@ void LCDefineBuffers() string lcFastBufferLabel = ShortName + " LC Fast (" + (string)lcFastLength + ")"; ENUM_DRAW_TYPE lcFastDrawType = lcDrawFast ? lcDrawType : DRAW_NONE; ArraySetAsSeries(lcFastBuffer, true); - SetIndexBuffer(lcFastBufferIndex, lcFastBuffer, INDICATOR_DATA); - PlotIndexSetString(lcFastBufferIndex, PLOT_LABEL, lcFastBufferLabel); - PlotIndexSetInteger(lcFastBufferIndex, PLOT_LINE_COLOR, lcFastColor); - PlotIndexSetInteger(lcFastBufferIndex, PLOT_LINE_STYLE, lcDrawStyle); - PlotIndexSetInteger(lcFastBufferIndex, PLOT_LINE_WIDTH, lcDrawWidth); - PlotIndexSetInteger(lcFastBufferIndex, PLOT_DRAW_BEGIN, lcFastLength); - PlotIndexSetInteger(lcFastBufferIndex, PLOT_DRAW_TYPE, lcFastDrawType); + SetIndexBuffer(lcFastBufferIndex, lcFastBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(lcFastBufferIndex, lcFastBuffer, INDICATOR_DATA); + // PlotIndexSetString(lcFastBufferIndex, PLOT_LABEL, lcFastBufferLabel); + // PlotIndexSetInteger(lcFastBufferIndex, PLOT_LINE_COLOR, lcFastColor); + // PlotIndexSetInteger(lcFastBufferIndex, PLOT_LINE_STYLE, lcDrawStyle); + // PlotIndexSetInteger(lcFastBufferIndex, PLOT_LINE_WIDTH, lcDrawWidth); + // PlotIndexSetInteger(lcFastBufferIndex, PLOT_DRAW_BEGIN, lcFastLength); + // PlotIndexSetInteger(lcFastBufferIndex, PLOT_DRAW_TYPE, lcFastDrawType); // // LC Slow Buffer ... string lcSlowBufferLabel = ShortName + " LC Slow (" + (string)lcSlowLength + ")"; ENUM_DRAW_TYPE lcSlowDrawType = lcDrawSlow ? lcDrawType : DRAW_NONE; ArraySetAsSeries(lcSlowBuffer, true); - SetIndexBuffer(lcSlowBufferIndex, lcSlowBuffer, INDICATOR_DATA); - PlotIndexSetString(lcSlowBufferIndex, PLOT_LABEL, lcSlowBufferLabel); - PlotIndexSetInteger(lcSlowBufferIndex, PLOT_LINE_COLOR, lcSlowColor); - PlotIndexSetInteger(lcSlowBufferIndex, PLOT_LINE_STYLE, lcDrawStyle); - PlotIndexSetInteger(lcSlowBufferIndex, PLOT_LINE_WIDTH, lcDrawWidth); - PlotIndexSetInteger(lcSlowBufferIndex, PLOT_DRAW_BEGIN, lcSlowLength); - PlotIndexSetInteger(lcSlowBufferIndex, PLOT_DRAW_TYPE, lcSlowDrawType); + SetIndexBuffer(lcSlowBufferIndex, lcSlowBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(lcSlowBufferIndex, lcSlowBuffer, INDICATOR_DATA); + // PlotIndexSetString(lcSlowBufferIndex, PLOT_LABEL, lcSlowBufferLabel); + // PlotIndexSetInteger(lcSlowBufferIndex, PLOT_LINE_COLOR, lcSlowColor); + // PlotIndexSetInteger(lcSlowBufferIndex, PLOT_LINE_STYLE, lcDrawStyle); + // PlotIndexSetInteger(lcSlowBufferIndex, PLOT_LINE_WIDTH, lcDrawWidth); + // PlotIndexSetInteger(lcSlowBufferIndex, PLOT_DRAW_BEGIN, lcSlowLength); + // PlotIndexSetInteger(lcSlowBufferIndex, PLOT_DRAW_TYPE, lcSlowDrawType); } // @@ -550,26 +554,28 @@ void MCDefineBuffers() string mcFastBufferLabel = ShortName + " MC Fast (" + (string)mcFastLength + ")"; ENUM_DRAW_TYPE mcFastDrawType = mcDrawFast ? lcDrawType : DRAW_NONE; ArraySetAsSeries(mcFastBuffer, true); - SetIndexBuffer(mcFastBufferIndex, mcFastBuffer, INDICATOR_DATA); - PlotIndexSetString(mcFastBufferIndex, PLOT_LABEL, mcFastBufferLabel); - PlotIndexSetInteger(mcFastBufferIndex, PLOT_LINE_COLOR, mcFastColor); - PlotIndexSetInteger(mcFastBufferIndex, PLOT_LINE_STYLE, mcDrawStyle); - PlotIndexSetInteger(mcFastBufferIndex, PLOT_LINE_WIDTH, mcDrawWidth); - PlotIndexSetInteger(mcFastBufferIndex, PLOT_DRAW_BEGIN, mcFastLength); - PlotIndexSetInteger(mcFastBufferIndex, PLOT_DRAW_TYPE, mcFastDrawType); + SetIndexBuffer(mcFastBufferIndex, mcFastBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(mcFastBufferIndex, mcFastBuffer, INDICATOR_DATA); + // PlotIndexSetString(mcFastBufferIndex, PLOT_LABEL, mcFastBufferLabel); + // PlotIndexSetInteger(mcFastBufferIndex, PLOT_LINE_COLOR, mcFastColor); + // PlotIndexSetInteger(mcFastBufferIndex, PLOT_LINE_STYLE, mcDrawStyle); + // PlotIndexSetInteger(mcFastBufferIndex, PLOT_LINE_WIDTH, mcDrawWidth); + // PlotIndexSetInteger(mcFastBufferIndex, PLOT_DRAW_BEGIN, mcFastLength); + // PlotIndexSetInteger(mcFastBufferIndex, PLOT_DRAW_TYPE, mcFastDrawType); // // MC Slow Buffer ... string mcSlowBufferLabel = ShortName + " MC Slow (" + (string)mcSlowLength + ")"; ENUM_DRAW_TYPE mcSlowDrawType = mcDrawSlow ? lcDrawType : DRAW_NONE; ArraySetAsSeries(mcSlowBuffer, true); - SetIndexBuffer(mcSlowBufferIndex, mcSlowBuffer, INDICATOR_DATA); - PlotIndexSetString(mcSlowBufferIndex, PLOT_LABEL, mcSlowBufferLabel); - PlotIndexSetInteger(mcSlowBufferIndex, PLOT_LINE_COLOR, mcSlowColor); - PlotIndexSetInteger(mcSlowBufferIndex, PLOT_LINE_STYLE, mcDrawStyle); - PlotIndexSetInteger(mcSlowBufferIndex, PLOT_LINE_WIDTH, mcDrawWidth); - PlotIndexSetInteger(mcSlowBufferIndex, PLOT_DRAW_BEGIN, mcSlowLength); - PlotIndexSetInteger(mcSlowBufferIndex, PLOT_DRAW_TYPE, mcSlowDrawType); + SetIndexBuffer(mcSlowBufferIndex, mcSlowBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(mcSlowBufferIndex, mcSlowBuffer, INDICATOR_DATA); + // PlotIndexSetString(mcSlowBufferIndex, PLOT_LABEL, mcSlowBufferLabel); + // PlotIndexSetInteger(mcSlowBufferIndex, PLOT_LINE_COLOR, mcSlowColor); + // PlotIndexSetInteger(mcSlowBufferIndex, PLOT_LINE_STYLE, mcDrawStyle); + // PlotIndexSetInteger(mcSlowBufferIndex, PLOT_LINE_WIDTH, mcDrawWidth); + // PlotIndexSetInteger(mcSlowBufferIndex, PLOT_DRAW_BEGIN, mcSlowLength); + // PlotIndexSetInteger(mcSlowBufferIndex, PLOT_DRAW_TYPE, mcSlowDrawType); } // @@ -581,26 +587,28 @@ void SCDefineBuffers() string scFastBufferLabel = ShortName + " SC Fast (" + (string)scFastLength + ")"; ENUM_DRAW_TYPE scFastDrawType = scDrawFast ? lcDrawType : DRAW_NONE; ArraySetAsSeries(scFastBuffer, true); - SetIndexBuffer(scFastBufferIndex, scFastBuffer, INDICATOR_DATA); - PlotIndexSetString(scFastBufferIndex, PLOT_LABEL, scFastBufferLabel); - PlotIndexSetInteger(scFastBufferIndex, PLOT_LINE_COLOR, scFastColor); - PlotIndexSetInteger(scFastBufferIndex, PLOT_LINE_STYLE, scDrawStyle); - PlotIndexSetInteger(scFastBufferIndex, PLOT_LINE_WIDTH, scDrawWidth); - PlotIndexSetInteger(scFastBufferIndex, PLOT_DRAW_BEGIN, scFastLength); - PlotIndexSetInteger(scFastBufferIndex, PLOT_DRAW_TYPE, scFastDrawType); + SetIndexBuffer(scFastBufferIndex, scFastBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(scFastBufferIndex, scFastBuffer, INDICATOR_DATA); + // PlotIndexSetString(scFastBufferIndex, PLOT_LABEL, scFastBufferLabel); + // PlotIndexSetInteger(scFastBufferIndex, PLOT_LINE_COLOR, scFastColor); + // PlotIndexSetInteger(scFastBufferIndex, PLOT_LINE_STYLE, scDrawStyle); + // PlotIndexSetInteger(scFastBufferIndex, PLOT_LINE_WIDTH, scDrawWidth); + // PlotIndexSetInteger(scFastBufferIndex, PLOT_DRAW_BEGIN, scFastLength); + // PlotIndexSetInteger(scFastBufferIndex, PLOT_DRAW_TYPE, scFastDrawType); // // SC Slow Buffer ... string scSlowBufferLabel = ShortName + " SC Slow (" + (string)scSlowLength + ")"; ENUM_DRAW_TYPE scSlowDrawType = scDrawSlow ? lcDrawType : DRAW_NONE; ArraySetAsSeries(scSlowBuffer, true); - SetIndexBuffer(scSlowBufferIndex, scSlowBuffer, INDICATOR_DATA); - PlotIndexSetString(scSlowBufferIndex, PLOT_LABEL, scSlowBufferLabel); - PlotIndexSetInteger(scSlowBufferIndex, PLOT_LINE_COLOR, scSlowColor); - PlotIndexSetInteger(scSlowBufferIndex, PLOT_LINE_STYLE, scDrawStyle); - PlotIndexSetInteger(scSlowBufferIndex, PLOT_LINE_WIDTH, scDrawWidth); - PlotIndexSetInteger(scSlowBufferIndex, PLOT_DRAW_BEGIN, scSlowLength); - PlotIndexSetInteger(scSlowBufferIndex, PLOT_DRAW_TYPE, scSlowDrawType); + SetIndexBuffer(scSlowBufferIndex, scSlowBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(scSlowBufferIndex, scSlowBuffer, INDICATOR_DATA); + // PlotIndexSetString(scSlowBufferIndex, PLOT_LABEL, scSlowBufferLabel); + // PlotIndexSetInteger(scSlowBufferIndex, PLOT_LINE_COLOR, scSlowColor); + // PlotIndexSetInteger(scSlowBufferIndex, PLOT_LINE_STYLE, scDrawStyle); + // PlotIndexSetInteger(scSlowBufferIndex, PLOT_LINE_WIDTH, scDrawWidth); + // PlotIndexSetInteger(scSlowBufferIndex, PLOT_DRAW_BEGIN, scSlowLength); + // PlotIndexSetInteger(scSlowBufferIndex, PLOT_DRAW_TYPE, scSlowDrawType); } // diff --git a/Indicators/x-saherelm.xfi.mq5 b/Indicators/x-saherelm.xfi.mq5 index 3f61fd7e..44f2c4d6 100644 --- a/Indicators/x-saherelm.xfi.mq5 +++ b/Indicators/x-saherelm.xfi.mq5 @@ -45,11 +45,13 @@ input ENUM_APPLIED_VOLUME appliedTo = VOLUME_TICK; // Applied To // // START Buffers ... // -#property indicator_separate_window +// #property indicator_separate_window +#property indicator_chart_window // #property indicator_buffers 2 -#property indicator_plots 1 +// #property indicator_plots 1 +#property indicator_plots 0 // // FI Buffer ... @@ -61,11 +63,11 @@ double fiBuffer[]; double fiColorBuffer[]; // -#property indicator_label1 "XFI" -#property indicator_type1 DRAW_COLOR_LINE -#property indicator_color1 clrAqua, clrGray, clrFuchsia -#property indicator_style1 STYLE_DOT -#property indicator_width1 1 +// #property indicator_label1 "XFI" +// #property indicator_type1 DRAW_COLOR_LINE +// #property indicator_color1 clrAqua, clrGray, clrFuchsia +// #property indicator_style1 STYLE_DOT +// #property indicator_width1 1 // // END Buffers ... // @@ -261,13 +263,15 @@ void DefineBuffers() // // FI Buffer ... ArraySetAsSeries(fiBuffer, true); - SetIndexBuffer(fiBufferIndex, fiBuffer, INDICATOR_DATA); - PlotIndexSetString(fiBufferIndex, PLOT_LABEL, fiBufferLabel); + SetIndexBuffer(fiBufferIndex, fiBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(fiBufferIndex, fiBuffer, INDICATOR_DATA); + // PlotIndexSetString(fiBufferIndex, PLOT_LABEL, fiBufferLabel); - // - // FI Color Buffer ... + // // + // // FI Color Buffer ... ArraySetAsSeries(fiColorBuffer, true); - SetIndexBuffer(fiColorBufferIndex, fiColorBuffer, INDICATOR_COLOR_INDEX); + // SetIndexBuffer(fiColorBufferIndex, fiColorBuffer, INDICATOR_COLOR_INDEX); + SetIndexBuffer(fiColorBufferIndex, fiColorBuffer, INDICATOR_CALCULATIONS); } // diff --git a/Indicators/x-saherelm.xrsi.mq5 b/Indicators/x-saherelm.xrsi.mq5 index babf20d7..f581113c 100644 --- a/Indicators/x-saherelm.xrsi.mq5 +++ b/Indicators/x-saherelm.xrsi.mq5 @@ -75,9 +75,11 @@ input ENUM_LINE_STYLE longExitLineStyle = STYLE_DOT; // Long Exit Style // // -#property indicator_separate_window +// #property indicator_separate_window +#property indicator_chart_window #property indicator_buffers 2 -#property indicator_plots 1 +// #property indicator_plots 1 +#property indicator_plots 0 // #define rsiBufferIndex 0 @@ -88,11 +90,11 @@ double rsiBuffer[]; double rsiColorBuffer[]; // -#property indicator_label1 "XRSI" -#property indicator_type1 DRAW_COLOR_LINE -#property indicator_color1 clrAqua, clrGray, clrFuchsia -#property indicator_style1 STYLE_DOT -#property indicator_width1 1 +// #property indicator_label1 "XRSI" +// #property indicator_type1 DRAW_COLOR_LINE +// #property indicator_color1 clrAqua, clrGray, clrFuchsia +// #property indicator_style1 STYLE_DOT +// #property indicator_width1 1 // // END Buffers ... @@ -288,14 +290,16 @@ void DefineBuffers() // RSI ... string rsiBufferLabel = ShortName + " (" + (string)length + ")"; ArraySetAsSeries(rsiBuffer, true); - SetIndexBuffer(rsiBufferIndex, rsiBuffer, INDICATOR_DATA); - PlotIndexSetInteger(rsiBufferIndex, PLOT_DRAW_BEGIN, length); - PlotIndexSetString(rsiBufferIndex, PLOT_LABEL, rsiBufferLabel); + SetIndexBuffer(rsiBufferIndex, rsiBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(rsiBufferIndex, rsiBuffer, INDICATOR_DATA); + // PlotIndexSetInteger(rsiBufferIndex, PLOT_DRAW_BEGIN, length); + // PlotIndexSetString(rsiBufferIndex, PLOT_LABEL, rsiBufferLabel); - // - // RSI Color Buffer ... + // // + // // RSI Color Buffer ... ArraySetAsSeries(rsiColorBuffer, true); - SetIndexBuffer(rsiColorBufferIndex, rsiColorBuffer, INDICATOR_COLOR_INDEX); + SetIndexBuffer(rsiColorBufferIndex, rsiColorBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(rsiColorBufferIndex, rsiColorBuffer, INDICATOR_COLOR_INDEX); // // Set Indicator Levels here ... diff --git a/Indicators/x-saherelm.xtd.mq5 b/Indicators/x-saherelm.xtd.mq5 index d762b395..ca796955 100644 --- a/Indicators/x-saherelm.xtd.mq5 +++ b/Indicators/x-saherelm.xtd.mq5 @@ -68,11 +68,13 @@ input color bearishArrowColor = clrMagenta; // Cross Under Arrow Color // // START Buffers ... // -#property indicator_separate_window +// #property indicator_separate_window +#property indicator_chart_window // #property indicator_buffers 3 -#property indicator_plots 3 +// #property indicator_plots 3 +#property indicator_plots 0 // #define bullishBufferIndex 0 @@ -85,25 +87,25 @@ double bearishBuffer[]; double signalBuffer[]; // -#property indicator_label1 "XBullPower" -#property indicator_type1 DRAW_LINE -#property indicator_color1 clrLime -#property indicator_style1 STYLE_SOLID -#property indicator_width1 1 +// #property indicator_label1 "XBullPower" +// #property indicator_type1 DRAW_LINE +// #property indicator_color1 clrLime +// #property indicator_style1 STYLE_SOLID +// #property indicator_width1 1 // -#property indicator_label2 "XBearPower" -#property indicator_type2 DRAW_LINE -#property indicator_color2 clrRed -#property indicator_style2 STYLE_SOLID -#property indicator_width2 1 +// #property indicator_label2 "XBearPower" +// #property indicator_type2 DRAW_LINE +// #property indicator_color2 clrRed +// #property indicator_style2 STYLE_SOLID +// #property indicator_width2 1 // -#property indicator_label3 "XSignal" -#property indicator_type3 DRAW_LINE -#property indicator_color3 clrGold -#property indicator_style3 STYLE_DOT -#property indicator_width3 1 +// #property indicator_label3 "XSignal" +// #property indicator_type3 DRAW_LINE +// #property indicator_color3 clrGold +// #property indicator_style3 STYLE_DOT +// #property indicator_width3 1 // // END Buffers ... // @@ -273,25 +275,28 @@ void DefineBuffers() // Bullish Buffer ... string bullishBufferLabel = ShortName + "BullPow " + "(" + (string)length + ")"; ArraySetAsSeries(bullishBuffer, true); - SetIndexBuffer(bullishBufferIndex, bullishBuffer, INDICATOR_DATA); - PlotIndexSetInteger(bullishBufferIndex, PLOT_DRAW_BEGIN, length); - PlotIndexSetString(bullishBufferIndex, PLOT_LABEL, bullishBufferLabel); + SetIndexBuffer(bullishBufferIndex, bullishBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(bullishBufferIndex, bullishBuffer, INDICATOR_DATA); + // PlotIndexSetInteger(bullishBufferIndex, PLOT_DRAW_BEGIN, length); + // PlotIndexSetString(bullishBufferIndex, PLOT_LABEL, bullishBufferLabel); // // Bearish Buffer ... string bearishBufferLabel = ShortName + "BearPow " + "(" + (string)length + ")"; ArraySetAsSeries(bearishBuffer, true); - SetIndexBuffer(bearishBufferIndex, bearishBuffer, INDICATOR_DATA); - PlotIndexSetInteger(bearishBufferIndex, PLOT_DRAW_BEGIN, length); - PlotIndexSetString(bearishBufferIndex, PLOT_LABEL, bearishBufferLabel); + SetIndexBuffer(bearishBufferIndex, bearishBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(bearishBufferIndex, bearishBuffer, INDICATOR_DATA); + // PlotIndexSetInteger(bearishBufferIndex, PLOT_DRAW_BEGIN, length); + // PlotIndexSetString(bearishBufferIndex, PLOT_LABEL, bearishBufferLabel); // // Signal Buffer ... string signalBufferLabel = ShortName + "Signal " + "(" + (string)length + ")"; ArraySetAsSeries(signalBuffer, true); - SetIndexBuffer(signalBufferIndex, signalBuffer, INDICATOR_DATA); - PlotIndexSetInteger(signalBufferIndex, PLOT_DRAW_BEGIN, length); - PlotIndexSetString(signalBufferIndex, PLOT_LABEL, signalBufferLabel); + SetIndexBuffer(signalBufferIndex, signalBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(signalBufferIndex, signalBuffer, INDICATOR_DATA); + // PlotIndexSetInteger(signalBufferIndex, PLOT_DRAW_BEGIN, length); + // PlotIndexSetString(signalBufferIndex, PLOT_LABEL, signalBufferLabel); } // diff --git a/Indicators/x-saherelm.xts.mq5 b/Indicators/x-saherelm.xts.mq5 index 00afe83c..cbcf7a7e 100644 --- a/Indicators/x-saherelm.xts.mq5 +++ b/Indicators/x-saherelm.xts.mq5 @@ -62,11 +62,13 @@ input ENUM_APPLIED_PRICE farestAppliedTo = PRICE_CLOSE; // Farest Applied To // // START Buffers ... // -#property indicator_separate_window +// #property indicator_separate_window +#property indicator_chart_window // #property indicator_buffers 4 -#property indicator_plots 4 +// #property indicator_plots 4 +#property indicator_plots 0 // // Current ... @@ -74,11 +76,11 @@ input ENUM_APPLIED_PRICE farestAppliedTo = PRICE_CLOSE; // Farest Applied To double currentBuffer[]; -#property indicator_label1 "XTS C" -#property indicator_type1 DRAW_LINE -#property indicator_color1 clrBrown -#property indicator_style1 STYLE_SOLID -#property indicator_width1 1 +// #property indicator_label1 "XTS C" +// #property indicator_type1 DRAW_LINE +// #property indicator_color1 clrBrown +// #property indicator_style1 STYLE_SOLID +// #property indicator_width1 1 // // Nearest ... @@ -86,11 +88,11 @@ double currentBuffer[]; double nearestBuffer[]; -#property indicator_label2 "XTS N" -#property indicator_type2 DRAW_LINE -#property indicator_color2 clrAqua -#property indicator_style2 STYLE_SOLID -#property indicator_width2 1 +// #property indicator_label2 "XTS N" +// #property indicator_type2 DRAW_LINE +// #property indicator_color2 clrAqua +// #property indicator_style2 STYLE_SOLID +// #property indicator_width2 1 // // Mediest ... @@ -98,11 +100,11 @@ double nearestBuffer[]; double mediestBuffer[]; -#property indicator_label3 "XTS M" -#property indicator_type3 DRAW_LINE -#property indicator_color3 clrLime -#property indicator_style3 STYLE_SOLID -#property indicator_width3 1 +// #property indicator_label3 "XTS M" +// #property indicator_type3 DRAW_LINE +// #property indicator_color3 clrLime +// #property indicator_style3 STYLE_SOLID +// #property indicator_width3 1 // // Farest ... @@ -110,11 +112,11 @@ double mediestBuffer[]; double farestBuffer[]; -#property indicator_label4 "XTS F" -#property indicator_type4 DRAW_LINE -#property indicator_color4 clrLightBlue -#property indicator_style4 STYLE_SOLID -#property indicator_width4 1 +// #property indicator_label4 "XTS F" +// #property indicator_type4 DRAW_LINE +// #property indicator_color4 clrLightBlue +// #property indicator_style4 STYLE_SOLID +// #property indicator_width4 1 // // END Buffers ... @@ -273,26 +275,30 @@ void DefineBuffers() // // Current ... ArraySetAsSeries(currentBuffer, true); - SetIndexBuffer(currentBufferIndex, currentBuffer, INDICATOR_DATA); - PlotIndexSetInteger(currentBufferIndex, PLOT_DRAW_BEGIN, maxLength); + SetIndexBuffer(currentBufferIndex, currentBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(currentBufferIndex, currentBuffer, INDICATOR_DATA); + // PlotIndexSetInteger(currentBufferIndex, PLOT_DRAW_BEGIN, maxLength); // // Nearest ... ArraySetAsSeries(nearestBuffer, true); - SetIndexBuffer(nearestBufferIndex, nearestBuffer, INDICATOR_DATA); - PlotIndexSetInteger(nearestBufferIndex, PLOT_DRAW_BEGIN, maxLength); + SetIndexBuffer(nearestBufferIndex, nearestBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(nearestBufferIndex, nearestBuffer, INDICATOR_DATA); + // PlotIndexSetInteger(nearestBufferIndex, PLOT_DRAW_BEGIN, maxLength); // // Mediest ... ArraySetAsSeries(mediestBuffer, true); - SetIndexBuffer(mediestBufferIndex, mediestBuffer, INDICATOR_DATA); - PlotIndexSetInteger(mediestBufferIndex, PLOT_DRAW_BEGIN, maxLength); + SetIndexBuffer(mediestBufferIndex, mediestBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(mediestBufferIndex, mediestBuffer, INDICATOR_DATA); + // PlotIndexSetInteger(mediestBufferIndex, PLOT_DRAW_BEGIN, maxLength); // // Farest ... ArraySetAsSeries(farestBuffer, true); - SetIndexBuffer(farestBufferIndex, farestBuffer, INDICATOR_DATA); - PlotIndexSetInteger(farestBufferIndex, PLOT_DRAW_BEGIN, maxLength); + SetIndexBuffer(farestBufferIndex, farestBuffer, INDICATOR_CALCULATIONS); + // SetIndexBuffer(farestBufferIndex, farestBuffer, INDICATOR_DATA); + // PlotIndexSetInteger(farestBufferIndex, PLOT_DRAW_BEGIN, maxLength); } //