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