/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 Class Library // ---------------------------------------------- // Name: XSC121Provider // Description: provides all Base Provider // requirements For X121 ... // // // 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.xcc.helper.mq5" #include "../Helpers/x-saherelm.xct.helper.mq5" #include "../Helpers/x-saherelm.xmc.helper.mq5" #include "../Helpers/x-saherelm.xdon.helper.mq5" #include "../Helpers/x-saherelm.xzg.helper.mq5" #include "../Helpers/x-saherelm.xpv.helper.mq5" #include "../Helpers/x-saherelm.xstr.helper.mq5" #include "../Helpers/x-saherelm.xche.helper.mq5" #include "../Helpers/x-saherelm.xosc.helper.mq5" // #include "../Classes/x-saherelm.xprovider.class.mq5" #include "../Classes/x-saherelm.x121.xmcycle.class.mq5" // // Definitions ... // // Signallers ... enum ENUM_X121_SIGNAL_PROVIDERS { // X121NONE, X121XSP, XTEST, X786, X121, X110, X92, }; // // X121 Provider Inputs ... class X121ProviderInputs : public XSCBaseProviderInpts { // // Public ... public: // // Props ... // string symbol; ENUM_TIMEFRAMES period; // // S Market ... ENUM_TIMEFRAMES sMarketPeriod; // Short Market Period ENUM_X_PERIOD_METHOD sMarketMethod; // Short Market Period Method string sMarketPrefix; // Short Market Prefix // // MEDIUM Market ... ENUM_TIMEFRAMES mMarketPeriod; // Medium Market Period ENUM_X_PERIOD_METHOD mMarketMethod; // Medium Market Period Method string mMarketPrefix; // Medium Market Prefix // // LONG Market ... ENUM_TIMEFRAMES lMarketPeriod; // Long Market Period ENUM_X_PERIOD_METHOD lMarketMethod; // Long Market Period Method string lMarketPrefix; // Long Market Prefix // // HIND Market ... ENUM_TIMEFRAMES hMarketPeriod; // Hind Market Period ENUM_X_PERIOD_METHOD hMarketMethod; // Hind Market Period Method string hMarketPrefix; // Hind Market Prefix // // Indicators ... XCCInputs ccInputs; XCTInputs ctInputs; XZGInputs zgInputs; XPVInputs pvInputs; XMCInputs mcInputs; XICHInputs ichInputs; XCHEInputs cheInputs; XSTRInputs strInputs; XDONInputs donInputs; XOSCInputs oscInputs; // X121MCycleInputs cMarketInputs; // Curent Market Inputs X121MCycleInputs sMarketInputs; // Short Market Inputs X121MCycleInputs mMarketInputs; // Medium Market Inputs X121MCycleInputs lMarketInputs; // Long Market Inputs X121MCycleInputs hMarketInputs; // Hind Market Inputs // // Tools ... // // Initialize Input ... bool Init() { // bool result = false; // // Validate Base Requirements ... result = // IsSpecifiedValid(symbol) && IsSpecifiedValid(period) && IsSpecifiedValid(sMarketMethod, sMarketPeriod) && IsSpecifiedValid(mMarketMethod, mMarketPeriod) && IsSpecifiedValid(lMarketMethod, lMarketPeriod) && IsSpecifiedValid(hMarketMethod, hMarketPeriod) // ; if (!result) { return result; } // if (!zgInputs.IsValid()) { zgInputs.Default(); } if (!pvInputs.IsValid()) { pvInputs.Default(); } if (!mcInputs.IsValid()) { mcInputs.Default(); } if (!cheInputs.IsValid()) { cheInputs.Default(); } if (!strInputs.IsValid()) { strInputs.Default(); } if (!donInputs.IsValid()) { donInputs.Default(); } if (!oscInputs.IsValid()) { oscInputs.Default(); } if (!ichInputs.IsValid()) { ichInputs.Default(); } // // // if (!cMarketInputs.IsValid()) // { // cMarketInputs.Default(); // } // if (!sMarketInputs.IsValid()) // { // sMarketInputs.Default(); // } // if (!mMarketInputs.IsValid()) // { // mMarketInputs.Default(); // } // if (!lMarketInputs.IsValid()) // { // lMarketInputs.Default(); // } // if (!hMarketInputs.IsValid()) // { // hMarketInputs.Default(); // } // // Initialize Market Inputs ... // // Current ... cMarketInputs.mcInputs = this.mcInputs; cMarketInputs.strInputs = this.strInputs; cMarketInputs.oscInputs = this.oscInputs; cMarketInputs.cheInputs = this.cheInputs; cMarketInputs.ichInputs = this.ichInputs; result = cMarketInputs.Init( this.symbol, this.period, X_MARKET_CYCLE_SHORT, this.period, X_PERIOD_MANUALLY, "HOST", false // ); if (!result) { return result; } // // Short ... sMarketInputs.mcInputs = this.mcInputs; sMarketInputs.strInputs = this.strInputs; sMarketInputs.oscInputs = this.oscInputs; sMarketInputs.cheInputs = this.cheInputs; sMarketInputs.ichInputs = this.ichInputs; result = sMarketInputs.Init( this.symbol, this.period, X_MARKET_CYCLE_SHORT, this.sMarketPeriod, this.sMarketMethod, this.sMarketPrefix, false // ); if (!result) { return result; } // // Medium ... mMarketInputs.mcInputs = this.mcInputs; mMarketInputs.strInputs = this.strInputs; mMarketInputs.oscInputs = this.oscInputs; mMarketInputs.cheInputs = this.cheInputs; mMarketInputs.ichInputs = this.ichInputs; result = mMarketInputs.Init( this.symbol, this.period, X_MARKET_CYCLE_MEDIUM, this.mMarketPeriod, this.mMarketMethod, this.mMarketPrefix, false // ); if (!result) { return result; } // // Long ... lMarketInputs.mcInputs = this.mcInputs; lMarketInputs.strInputs = this.strInputs; lMarketInputs.oscInputs = this.oscInputs; lMarketInputs.cheInputs = this.cheInputs; lMarketInputs.ichInputs = this.ichInputs; result = lMarketInputs.Init( this.symbol, this.period, X_MARKET_CYCLE_LONG, this.lMarketPeriod, this.lMarketMethod, this.lMarketPrefix, false // ); if (!result) { return result; } // // Hind ... hMarketInputs.mcInputs = this.mcInputs; hMarketInputs.strInputs = this.strInputs; hMarketInputs.oscInputs = this.oscInputs; hMarketInputs.cheInputs = this.cheInputs; hMarketInputs.ichInputs = this.ichInputs; result = hMarketInputs.Init( this.symbol, this.period, X_MARKET_CYCLE_HIND, this.hMarketPeriod, this.hMarketMethod, this.hMarketPrefix, false // ); if (!result) { return result; } // result = IsValid(); // return result; } // // Validate Input ... bool IsValid() override { // bool result = false; // result = // // IsSpecifiedValid(symbol) && IsSpecifiedValid(period) && IsSpecifiedValid(sMarketMethod, sMarketPeriod) && IsSpecifiedValid(mMarketMethod, mMarketPeriod) && IsSpecifiedValid(lMarketMethod, lMarketPeriod) && IsSpecifiedValid(hMarketMethod, hMarketPeriod) && // ccInputs.IsValid() && ctInputs.IsValid() && zgInputs.IsValid() && pvInputs.IsValid() && mcInputs.IsValid() && cheInputs.IsValid() && strInputs.IsValid() && donInputs.IsValid() && oscInputs.IsValid() && ichInputs.IsValid() && // cMarketInputs.IsValid() && sMarketInputs.IsValid() && mMarketInputs.IsValid() && lMarketInputs.IsValid() && hMarketInputs.IsValid() // ; // return result; } // // Cleanup ... void Clean() override { // symbol = NULL; period = NULL; // sMarketPeriod = NULL; sMarketMethod = X_PERIOD_NOTHING; sMarketPrefix = NULL; // mMarketPeriod = NULL; mMarketMethod = X_PERIOD_NOTHING; mMarketPrefix = NULL; // lMarketPeriod = NULL; lMarketMethod = X_PERIOD_NOTHING; lMarketPrefix = NULL; // hMarketPeriod = NULL; hMarketMethod = X_PERIOD_NOTHING; hMarketPrefix = NULL; // ccInputs.Clean(); ctInputs.Clean(); zgInputs.Clean(); pvInputs.Clean(); mcInputs.Clean(); cheInputs.Clean(); strInputs.Clean(); donInputs.Clean(); oscInputs.Clean(); ichInputs.Clean(); // cMarketInputs.Clean(); sMarketInputs.Clean(); mMarketInputs.Clean(); lMarketInputs.Clean(); hMarketInputs.Clean(); } // // Default ... void Default() override { // symbol = NULL; period = NULL; // sMarketPeriod = NULL; sMarketMethod = X_PERIOD_AUTO; sMarketPrefix = NULL; // mMarketPeriod = NULL; mMarketMethod = X_PERIOD_AUTO; mMarketPrefix = NULL; // lMarketPeriod = NULL; lMarketMethod = X_PERIOD_AUTO; lMarketPrefix = NULL; // hMarketPeriod = NULL; hMarketMethod = X_PERIOD_AUTO; hMarketPrefix = NULL; // ccInputs.Default(); ctInputs.Default(); zgInputs.Default(); pvInputs.Default(); mcInputs.Default(); cheInputs.Default(); strInputs.Default(); donInputs.Default(); oscInputs.Default(); ichInputs.Default(); cMarketInputs.Default(); sMarketInputs.Default(); mMarketInputs.Default(); lMarketInputs.Default(); hMarketInputs.Default(); } // // Max ... int Max() override { // int result = 0; // return result; } // // Set Symbol ... bool SetSymbol(string value) { // bool result = false; // result = IsSpecifiedValid(value); if (!result) { return result; } // symbol = value; cMarketInputs.cycle.symbol = value; sMarketInputs.cycle.symbol = value; mMarketInputs.cycle.symbol = value; lMarketInputs.cycle.symbol = value; hMarketInputs.cycle.symbol = value; // return result; } // // Set Period ... bool SetPeriod(ENUM_TIMEFRAMES value) { // bool result = false; // result = IsSpecifiedValid(value); if (!result) { return result; } // period = value; cMarketInputs.cycle.period = value; sMarketInputs.cycle.period = value; mMarketInputs.cycle.period = value; lMarketInputs.cycle.period = value; hMarketInputs.cycle.period = value; // return result; } // }; // // X121 Provider Market Conditions ... class X121MarketConditions : public XSCBaseProviderMarketConditions { // // Public ... public: // // XZG ... double zigzags[]; double zigzagPVs[]; // bool isZigZagInPeak; bool isZigZagInVale; // // XDON ... double donUpperOs[]; double donLowerOs[]; double donUpperCs[]; double donLowerCs[]; double donUpperHs[]; double donLowerHs[]; double donUpperLs[]; double donLowerLs[]; // bool isDONAttachedMaxLower; bool isDONAttachedMinLower; bool isDONCrossedOverMaxLower; bool isDONCrossedUnderMaxLower; // bool isDONAttachedMaxUpper; bool isDONAttachedMinUpper; bool isDONCrossedOverMaxUpper; bool isDONCrossedUnderMaxUpper; // // XPV ... double pvPeaks[]; double pvVales[]; double pvResistances[]; double pvSupports[]; double pvFib1s[]; double pvFib2s[]; double pvFib3s[]; double pvFib4s[]; double pvFib5s[]; double pvSCHHs[]; double pvSCLLs[]; double pvMCHHs[]; double pvMCLLs[]; double pvLCHHs[]; double pvLCLLs[]; double pvHCHHs[]; double pvHCLLs[]; // bool isPVPeakSameAs; bool isPVNewPeak; bool isPVNewPeakOverLast; bool isPVNewPeakUnderLast; bool isPVValeSameAs; bool isPVNewVale; bool isPVNewValeOverLast; bool isPVNewValeUnderLast; bool isPVFiboIncreased; bool isPVFiboDecreased; bool isPVFiboSectionChanged; // bool isPVSCBullish; bool isPVSCHHBullish; bool isPVSCLLBullish; bool isPVSCSwitchedToBullish; // bool isPVSCBearish; bool isPVSCHHBearish; bool isPVSCLLBearish; bool isPVSCSwitchedToBearish; // bool isPVMCBullish; bool isPVMCHHBullish; bool isPVMCLLBullish; bool isPVMCSwitchedToBullish; // bool isPVMCBearish; bool isPVMCHHBearish; bool isPVMCLLBearish; bool isPVMCSwitchedToBearish; // bool isPVLCBullish; bool isPVLCHHBullish; bool isPVLCLLBullish; bool isPVLCSwitchedToBullish; // bool isPVLCBearish; bool isPVLCHHBearish; bool isPVLCLLBearish; bool isPVLCSwitchedToBearish; // bool isPVHCBullish; bool isPVHCHHBullish; bool isPVHCLLBullish; bool isPVHCSwitchedToBullish; // bool isPVHCBearish; bool isPVHCHHBearish; bool isPVHCLLBearish; bool isPVHCSwitchedToBearish; // X121MCycleConditions cMarketConditions; // Current Market Conditions X121MCycleConditions sMarketConditions; // Short Market Conditions X121MCycleConditions mMarketConditions; // Medium Market Conditions X121MCycleConditions lMarketConditions; // Long Market Conditions X121MCycleConditions hMarketConditions; // Hind Market Conditions // // Tools ... // // Cleanup ... void Clear() { // symbol = NULL; period = NULL; // Clean(bars); Clean(zigzags); Clean(zigzagPVs); Clean(donUpperOs); Clean(donLowerOs); Clean(donUpperCs); Clean(donLowerCs); Clean(donUpperHs); Clean(donLowerHs); Clean(donUpperLs); Clean(donLowerLs); Clean(pvPeaks); Clean(pvVales); Clean(pvResistances); Clean(pvSupports); Clean(pvFib1s); Clean(pvFib2s); Clean(pvFib3s); Clean(pvFib4s); Clean(pvFib5s); Clean(pvSCHHs); Clean(pvSCLLs); Clean(pvMCHHs); Clean(pvMCLLs); Clean(pvLCHHs); Clean(pvLCLLs); Clean(pvHCHHs); Clean(pvHCLLs); // ArraySetAsSeries(bars, true); ArraySetAsSeries(zigzags, true); ArraySetAsSeries(zigzagPVs, true); ArraySetAsSeries(donUpperOs, true); ArraySetAsSeries(donLowerOs, true); ArraySetAsSeries(donUpperCs, true); ArraySetAsSeries(donLowerCs, true); ArraySetAsSeries(donUpperHs, true); ArraySetAsSeries(donLowerHs, true); ArraySetAsSeries(donUpperLs, true); ArraySetAsSeries(donLowerLs, true); ArraySetAsSeries(pvPeaks, true); ArraySetAsSeries(pvVales, true); ArraySetAsSeries(pvResistances, true); ArraySetAsSeries(pvSupports, true); ArraySetAsSeries(pvFib1s, true); ArraySetAsSeries(pvFib2s, true); ArraySetAsSeries(pvFib3s, true); ArraySetAsSeries(pvFib4s, true); ArraySetAsSeries(pvFib5s, true); ArraySetAsSeries(pvSCHHs, true); ArraySetAsSeries(pvSCLLs, true); ArraySetAsSeries(pvMCHHs, true); ArraySetAsSeries(pvMCLLs, true); ArraySetAsSeries(pvLCHHs, true); ArraySetAsSeries(pvLCLLs, true); ArraySetAsSeries(pvHCHHs, true); ArraySetAsSeries(pvHCLLs, true); // cMarketConditions.Clear(); sMarketConditions.Clear(); mMarketConditions.Clear(); lMarketConditions.Clear(); hMarketConditions.Clear(); } // void GenerateScore( double &bullishScore, // Bullish Score double &bearishScore, // Bearish Score double cMarketMultiplier = 1, // Current Market Score Multiplier double sMarketMultiplier = 1.1, // Short Market Score Multiplier double mMarketMultiplier = 1.2, // Medium Market Score Multiplier double lMarketMultiplier = 1.6, // Long Market Score Multiplier double hMarketMultiplier = 1.8 // Hind Market Score Multiplier ) { // // Current Market ... double cMarketBullScore = 0; double cMarketBearScore = 0; cMarketConditions.GenerateScore( cMarketBullScore, cMarketBearScore, cMarketMultiplier // ); // // Short Market ... double sMarketBullScore = 0; double sMarketBearScore = 0; sMarketConditions.GenerateScore( sMarketBullScore, sMarketBearScore, sMarketMultiplier // ); // // Medium Market ... double mMarketBullScore = 0; double mMarketBearScore = 0; mMarketConditions.GenerateScore( mMarketBullScore, mMarketBearScore, mMarketMultiplier // ); // // Long Market ... double lMarketBullScore = 0; double lMarketBearScore = 0; lMarketConditions.GenerateScore( lMarketBullScore, lMarketBearScore, lMarketMultiplier // ); // // Hind Market ... double hMarketBullScore = 0; double hMarketBearScore = 0; hMarketConditions.GenerateScore( hMarketBullScore, hMarketBearScore, hMarketMultiplier // ); // // Calculate Summary Scores ... // bullishScore = // cMarketBullScore + sMarketBullScore + mMarketBullScore + lMarketBullScore + hMarketBullScore // ; // bearishScore = // cMarketBearScore + sMarketBearScore + mMarketBearScore + lMarketBearScore + hMarketBearScore // ; // // Handle Scores for Current Conditions ... // // XZG ... if (isZigZagInPeak) { // bullishScore--; bearishScore++; } if (isZigZagInVale) { // bullishScore++; bearishScore--; } // // XDON ... if (isDONAttachedMaxLower) { // bullishScore++; bearishScore--; } if (isDONAttachedMinLower) { bearishScore++; } if (isDONCrossedOverMaxLower) { // bullishScore++; bearishScore--; } if (isDONCrossedUnderMaxLower) { // bullishScore--; bearishScore++; } if (isDONAttachedMaxUpper) { // bullishScore--; bearishScore++; } if (isDONAttachedMinUpper) { bullishScore++; } if (isDONCrossedOverMaxUpper) { // bullishScore++; bearishScore--; } if (isDONCrossedUnderMaxUpper) { // bullishScore--; bearishScore++; } // // XPV ... if (isPVPeakSameAs) { } if (isPVNewPeak) { } if (isPVNewPeakOverLast) { // bullishScore--; bearishScore++; } if (isPVNewPeakUnderLast) { // bullishScore++; bearishScore--; } if (isPVValeSameAs) { } if (isPVNewVale) { } if (isPVNewValeOverLast) { // bullishScore--; bearishScore++; } if (isPVNewValeUnderLast) { // bullishScore++; bearishScore--; } if (isPVFiboSectionChanged) { // if (isPVFiboIncreased) { // bullishScore++; bearishScore--; } if (isPVFiboDecreased) { // bullishScore--; bearishScore++; } } // if (isPVSCBullish) { bullishScore++; } if (isPVSCHHBullish) { bullishScore--; } if (isPVSCLLBullish) { bullishScore++; } if (isPVSCSwitchedToBullish) { // bullishScore++; bearishScore--; } if (isPVSCBearish) { bearishScore++; } if (isPVSCHHBearish) { bearishScore--; } if (isPVSCLLBearish) { bearishScore++; } if (isPVSCSwitchedToBearish) { // bullishScore--; bearishScore++; } if (isPVMCBullish) { bullishScore++; } if (isPVMCHHBullish) { bullishScore--; } if (isPVMCLLBullish) { bullishScore++; } if (isPVMCSwitchedToBullish) { // bullishScore++; bearishScore--; } if (isPVMCBearish) { bullishScore++; } if (isPVMCHHBearish) { bearishScore--; } if (isPVMCLLBearish) { bearishScore++; } if (isPVMCSwitchedToBearish) { // bullishScore--; bearishScore++; } if (isPVLCBullish) { bullishScore++; } if (isPVLCHHBullish) { bullishScore--; } if (isPVLCLLBullish) { bullishScore++; } if (isPVLCSwitchedToBullish) { // bullishScore++; bullishScore--; } if (isPVLCBearish) { bearishScore++; } if (isPVLCHHBearish) { bearishScore--; } if (isPVLCLLBearish) { bearishScore++; } if (isPVLCSwitchedToBearish) { // bullishScore--; bearishScore++; } if (isPVHCBullish) { bullishScore++; } if (isPVHCHHBullish) { bullishScore--; } if (isPVHCLLBullish) { bullishScore++; } if (isPVHCSwitchedToBullish) { // bullishScore++; bearishScore--; } if (isPVHCBearish) { bearishScore++; } if (isPVHCHHBearish) { bearishScore--; } if (isPVHCLLBearish) { bearishScore++; } if (isPVHCSwitchedToBearish) { // bullishScore--; bearishScore++; } } // string GenerateSummary( double cMarketMultiplier = 1, // Current Market Score Multiplier double sMarketMultiplier = 1.1, // Short Market Score Multiplier double mMarketMultiplier = 1.2, // Medium Market Score Multiplier double lMarketMultiplier = 1.6, // Long Market Score Multiplier double hMarketMultiplier = 1.8, // Hind Market Score Multiplier const string separator = "\n", // Separator string provided = NULL, // Additional Info about Type, Provider and Symbol const bool ignoreFalseConditions = true // Ignore False Conditions ) { // string result = NULL; // double bullScore = 0; double bearScore = 0; GenerateScore( bullScore, bearScore, cMarketMultiplier, sMarketMultiplier, mMarketMultiplier, lMarketMultiplier, hMarketMultiplier // ); // string commonStr = // "Commons: " + separator + "-----------------------------" + separator + "Symbol: " + symbol + separator + "Period: " + ToString(period) + separator + "Time: " + ToString(TimeCurrent()) + separator + "-----------" + separator + "Cycles: " + separator + "-----------" + separator + sMarketConditions.GetTitle() + separator + mMarketConditions.GetTitle() + separator + lMarketConditions.GetTitle() + separator + hMarketConditions.GetTitle() + separator + "-----------" + separator + "Scores: " + separator + "-----------" + separator + "Bullish: " + ToString(bullScore) + separator + "Bearish: " + ToString(bearScore) + separator + "-----------------------------" + separator + // // TODO: Add Scores Later ... separator + "" // ; // result = // "[" + GetToken() + "]" + separator + (IsSpecifiedValid(provided) ? provided + separator : "") + "-----------------------------" + separator + commonStr + "" // ; // 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(X121MarketConditions &items[]) { return -1; } }; // // Class ... // // X121 Provider Class ... class XSCX121Provider : public XSCBaseProvider { // // Public ... public: // // Props ... // XSCXCCHelper *ccHelper; // Candle Clear XSCXCTHelper *ctHelper; // Candle Timer XSCXZGHelper *zgHelper; // ZigZag Helper XSCXPVHelper *pvHelper; // Peaks and Vales Helper XSCXDONHelper *donHelper; // Donchain Helper; // XSCX121Market *cMarket; // Current Market XSCX121Market *sMarket; // Short Market XSCX121Market *mMarket; // Medium Market XSCX121Market *lMarket; // Long Market XSCX121Market *hMarket; // Hind Market // // Constructor ... XSCX121Provider( string symbol, // Trading Symbol ENUM_TIMEFRAMES period // Trading PEriod ) : XSCBaseProvider(symbol, period) { // ccHelper = new XSCXCCHelper(); ctHelper = new XSCXCTHelper(); // // Instantiate Helpers Classes ... zgHelper = new XSCXZGHelper(); pvHelper = new XSCXPVHelper(); donHelper = new XSCXDONHelper(); // // Instantiate X121 Market Cycles Classes ... cMarket = new XSCX121Market(); sMarket = new XSCX121Market(); mMarket = new XSCX121Market(); lMarket = new XSCX121Market(); hMarket = new XSCX121Market(); // mNumberOfItems = 15; } // // Properties Gettr(s) / Setter(s) ... // // Overrides ... // // DeInit all Requirements ... void DeInit() override { // delete ccHelper; delete ctHelper; // delete zgHelper; delete pvHelper; delete donHelper; // delete cMarket; delete sMarket; delete mMarket; delete lMarket; delete hMarket; } // // Functions ... // // Init all Requirements ... bool Init(X121ProviderInputs &inputs) { // bool result = false; // // Validate ... result = inputs.IsValid(); if (!result) { return result; } // mInputs = inputs; // string mSymbol = GetSymbol(); ENUM_TIMEFRAMES mPeriod = GetPeriod(); // // Init Indicators Helpers ... // // CT ... result = ctHelper .Init( mSymbol, mPeriod, mInputs.ctInputs // ); if (!result) { return result; } // // CC ... result = ccHelper .Init( mSymbol, mPeriod, mInputs.ccInputs // ); if (!result) { return result; } // // ZigZag ... result = zgHelper .Init( mSymbol, mPeriod, mInputs.zgInputs // ); if (!result) { return result; } // // PV ... result = pvHelper .Init( mSymbol, mPeriod, mInputs.pvInputs // ); if (!result) { return result; } // // DON ... result = donHelper .Init( mSymbol, mPeriod, mInputs.donInputs // ); if (!result) { return result; } // // Initialize X121 Market Cycles ... // // Current Market ... result = cMarket .Init(mInputs.cMarketInputs); if (!result) { return result; } // // Short Market ... result = sMarket .Init(mInputs.sMarketInputs); if (!result) { return result; } // // Medium Market ... result = mMarket .Init(mInputs.mMarketInputs); if (!result) { return result; } // // Long Market ... result = lMarket .Init(mInputs.lMarketInputs); if (!result) { return result; } // // Hind Market ... result = hMarket .Init(mInputs.hMarketInputs); if (!result) { return result; } // 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_X121_SIGNAL_PROVIDERS provider, // Provider State bool state // Which state is going to set ... ) { // if (provider == X121NONE) { return; } // switch (provider) { // case X121XSP: mIsX121XSPSignalProviderEnable = state; break; // case XTEST: mIsXTESTSignalProviderEnable = state; break; // case X786: mIsX786SignalProviderEnable = state; break; // case X121: mIsX121SignalProviderEnable = state; break; // case X110: mIsX110SignalProviderEnable = state; break; // case X92: mIsX92SignalProviderEnable = state; break; } } // void SetSignalProviderStates( ENUM_X121_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); } } // string GetTag() { // string result = NULL; // result = // GetToken() + "[" + GetSymbol() + "," + ToString(GetPeriod()) + "]" // ; // return result; } // void GetMarketConditions( X121MarketConditions &mConditions, // Market Conditions Result int barIndex = 0 // Specified Bar Index ) { // mConditions.Clear(); // CalculateConditions(mConditions, barIndex); } // // Check Market For Signal ... bool HasSignal( int barIndex, XSignal &mSignal, // Hold's Signal if Exists ... X121MarketConditions &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 = 60; double slPoint = 30; double volume = 0.01; double tpPrice = PointToPrice( tpPoint, symbol // ); double slPrice = PointToPrice( slPoint, 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 = hasLong ? entry - slPrice : entry + slPrice; 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; // // // TODO: // string providerTypeStr = GetSymbol() + ", " + provider + "(" + (hasLong ? "Long" : "Short") + ")"; // string mConditionsStr = mConditions.GenerateSummary(providerTypeStr, true); // mConditionsCollector.Add(mConditionsStr); // Print(mConditionsStr); } } // return result; } // void Draw() { // return; // // ulong chID = 0; // string symbol = GetSymbol(); ENUM_TIMEFRAMES period = GetPeriod(); // ulong chID = FindChartID( symbol, period); if (chID < 0) { return; } // int subWindow = 0; // int offset = 0; // cMarket.Draw(chID, subWindow, offset); sMarket.Draw(chID, subWindow, offset); mMarket.Draw(chID, subWindow, offset); lMarket.Draw(chID, subWindow, offset); hMarket.Draw(chID, subWindow, offset); } // // Protected ... protected: // X121ProviderInputs mInputs; // // Private ... private: // // Props ... // int mNumberOfItems; // Number of Buffer Ites Read in Conditions ... // // Signallers ... // bool mIsLongEnable; bool mIsShortEnable; // bool mIsX121XSPSignalProviderEnable; bool mIsX92SignalProviderEnable; bool mIsX786SignalProviderEnable; bool mIsX121SignalProviderEnable; bool mIsX110SignalProviderEnable; bool mIsXTESTSignalProviderEnable; // // // 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 ... X121MarketConditions &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 hasX121XSPSignal = false; bool hasXTESTSignal = false; bool hasX786Signal = false; bool hasX121Signal = false; bool hasX110Signal = false; bool hasX92Signal = false; // // XPS ... if (mIsX121XSPSignalProviderEnable) { // hasX121XSPSignal = X121XSPHasSpecifiedLongSignal( mConditions // ); // if (hasX121XSPSignal) { // if (!IsValid(provider)) { provider = ToString(X121XSP); } // signalPusher++; } } // // XTEST ... if (mIsXTESTSignalProviderEnable) { // hasXTESTSignal = XTESTHasSpecifiedLongSignal( mConditions // ); // if (hasXTESTSignal) { // if (!IsValid(provider)) { provider = ToString(XTEST); } // signalPusher++; } } // // X786 ... if (mIsX786SignalProviderEnable) { // hasX786Signal = X786HasSpecifiedLongSignal( mConditions // ); // if (hasX786Signal) { // if (!IsValid(provider)) { provider = ToString(X786); } // signalPusher++; } } // // X121 ... if (mIsX121SignalProviderEnable) { // hasX121Signal = XSIHasSpecifiedLongSignal( mConditions // ); // if (hasX121Signal) { // if (!IsValid(provider)) { provider = ToString(X121); } // signalPusher++; } } // // X110 ... if (mIsX110SignalProviderEnable) { // hasX110Signal = XTSFIHasSpecifiedLongSignal( mConditions // ); // if (hasX110Signal) { // if (!IsValid(provider)) { provider = ToString(X110); } // signalPusher++; } } // // X92 ... if (mIsX92SignalProviderEnable) { // hasX92Signal = XOBDLHHasSpecifiedLongSignal( mConditions // ); // if (hasX92Signal) { // if (!IsValid(provider)) { provider = ToString(X92); } // signalPusher++; } } // result = // hasX121XSPSignal // || // hasXTESTSignal // || // hasX786Signal // || // hasX121Signal // || // hasX110Signal // || // hasX92Signal // ; // if (result) { return result; } } // // Short ... if (!isLong && mIsShortEnable) { // XSignal sSignal; // signalPusher = 0; // bool hasX121XSPSignal = false; bool hasXTESTSignal = false; bool hasX786Signal = false; bool hasX121Signal = false; bool hasX110Signal = false; bool hasX92Signal = false; // // X121XSP ... if (mIsX121XSPSignalProviderEnable) { // hasX121XSPSignal = X121XSPHasSpecifiedShortSignal( mConditions // ); // if (hasX121XSPSignal) { // if (!IsValid(provider)) { provider = ToString(X121XSP); } // signalPusher++; } } // // XTEST ... if (mIsXTESTSignalProviderEnable) { // hasXTESTSignal = XTESTHasSpecifiedShortSignal( mConditions // ); // if (hasXTESTSignal) { // if (!IsValid(provider)) { provider = ToString(XTEST); } // signalPusher++; } } // // X786 ... if (mIsX786SignalProviderEnable) { // hasX786Signal = X786HasSpecifiedShortSignal( mConditions // ); // if (hasX786Signal) { // if (!IsValid(provider)) { provider = ToString(X786); } // signalPusher++; } } // // X121 ... if (mIsX121SignalProviderEnable) { // hasX121Signal = XSIHasSpecifiedShortSignal( mConditions // ); // if (hasX121Signal) { // if (!IsValid(provider)) { provider = ToString(X121); } // signalPusher++; } } // // X110 ... if (mIsX110SignalProviderEnable) { // hasX110Signal = XTSFIHasSpecifiedShortSignal( mConditions // ); // if (hasX110Signal) { // if (!IsValid(provider)) { provider = ToString(X110); } // signalPusher++; } } // // X92 ... if (mIsX92SignalProviderEnable) { // hasX92Signal = X92HasSpecifiedShortSignal( mConditions // ); // if (hasX92Signal) { // if (!IsValid(provider)) { provider = ToString(X92); } // signalPusher++; } } // result = // hasX121XSPSignal // || // hasXTESTSignal // || // hasX786Signal // || // hasX121Signal // || // hasX110Signal // || // hasX92Signal // ; // if (result) { return result; } } // return result; } // void CalculateConditions( X121MarketConditions &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 // ); // // XZG ... // zgHelper.CopyMain( barIndex, mNumberOfItems, mConditions.zigzags // ); // zgHelper.CopyPeaksAndVales( barIndex, mNumberOfItems, mConditions.zigzagPVs // ); // // Looking for Vale ... bool isZigZagInPeak = mConditions.zigzags[curr] < mConditions.zigzagPVs[curr]; mConditions.isZigZagInPeak = isZigZagInPeak; // // Looking for Peak ... bool isZigZagInVale = mConditions.zigzags[curr] > mConditions.zigzagPVs[curr]; mConditions.isZigZagInVale = isZigZagInVale; // // XDON ... // donHelper.CopyUpperO( barIndex, mNumberOfItems, mConditions.donUpperOs // ); donHelper.CopyLowerO( barIndex, mNumberOfItems, mConditions.donLowerOs // ); donHelper.CopyUpperC( barIndex, mNumberOfItems, mConditions.donUpperCs // ); donHelper.CopyLowerC( barIndex, mNumberOfItems, mConditions.donLowerCs // ); donHelper.CopyUpperH( barIndex, mNumberOfItems, mConditions.donUpperHs // ); donHelper.CopyLowerH( barIndex, mNumberOfItems, mConditions.donLowerHs // ); donHelper.CopyUpperL( barIndex, mNumberOfItems, mConditions.donUpperLs // ); donHelper.CopyLowerL( barIndex, mNumberOfItems, mConditions.donLowerLs // ); // // Upper ... // double donUpperO = mConditions.donUpperOs[curr]; double donUpperOPrev = mConditions.donUpperOs[prev]; // double donUpperC = mConditions.donUpperCs[curr]; double donUpperCPrev = mConditions.donUpperCs[prev]; // double donUpperH = mConditions.donUpperHs[curr]; double donUpperHPrev = mConditions.donUpperHs[prev]; // double donUpperL = mConditions.donUpperLs[curr]; double donUpperLPrev = mConditions.donUpperLs[prev]; // double donUppers[] = { donUpperO, donUpperC, donUpperH, donUpperL // }; double maxDonUpper = GetMax(donUppers); double minDonUpper = GetMin(donUppers); // double donUpperPrevs[] = { donUpperOPrev, donUpperCPrev, donUpperHPrev, donUpperLPrev // }; double maxDonUpperPrev = GetMax(donUpperPrevs); double minDonUpperPrev = GetMin(donUpperPrevs); // // Lower ... // double donLowerO = mConditions.donLowerOs[curr]; double donLowerOPrev = mConditions.donLowerOs[prev]; // double donLowerC = mConditions.donLowerCs[curr]; double donLowerCPrev = mConditions.donLowerCs[prev]; // double donLowerH = mConditions.donLowerHs[curr]; double donLowerHPrev = mConditions.donLowerHs[prev]; // double donLowerL = mConditions.donLowerLs[curr]; double donLowerLPrev = mConditions.donLowerLs[prev]; // double donLowers[] = { donLowerO, donLowerC, donLowerH, donLowerL // }; double maxDonLower = GetMax(donLowers); double minDonLower = GetMin(donLowers); // double donLowerPrevs[] = { donLowerOPrev, donLowerCPrev, donLowerHPrev, donLowerLPrev // }; double maxDonLowerPrev = GetMax(donLowerPrevs); double minDonLowerPrev = GetMin(donLowerPrevs); // bool isDONAttachedMaxLower = mConditions.bars[curr].low == maxDonLower; bool isDONAttachedMinLower = mConditions.bars[curr].low == minDonLower; bool isDONCrossedOverMaxLower = // ((mConditions.bars[curr].low > maxDonLower) || (mConditions.bars[curr].close > maxDonLower)) // && // ((mConditions.bars[prev].high <= maxDonLower) || (mConditions.bars[prev].open <= maxDonLower)) // ; bool isDONCrossedUnderMaxLower = // ((mConditions.bars[curr].low < maxDonLower) || (mConditions.bars[curr].close < maxDonLower)) // && // ((mConditions.bars[prev].high >= maxDonLower) || (mConditions.bars[prev].open >= maxDonLower)) // ; // bool isDONAttachedMaxUpper = mConditions.bars[curr].high == maxDonUpper; bool isDONAttachedMinUpper = mConditions.bars[curr].high == minDonUpper; bool isDONCrossedOverMaxUpper = // ((mConditions.bars[curr].low > maxDonUpper) || (mConditions.bars[curr].close > maxDonUpper)) // && // ((mConditions.bars[prev].high <= maxDonUpper) || (mConditions.bars[prev].open <= maxDonUpper)) // ; bool isDONCrossedUnderMaxUpper = // ((mConditions.bars[curr].low < maxDonUpper) || (mConditions.bars[curr].close < maxDonUpper)) // && // ((mConditions.bars[prev].high >= maxDonUpper) || (mConditions.bars[prev].open >= maxDonUpper)) // ; // mConditions.isDONAttachedMaxLower = isDONAttachedMaxLower; mConditions.isDONAttachedMinLower = isDONAttachedMinLower; mConditions.isDONCrossedOverMaxLower = isDONCrossedOverMaxLower; mConditions.isDONCrossedUnderMaxLower = isDONCrossedUnderMaxLower; // mConditions.isDONAttachedMaxUpper = isDONAttachedMaxUpper; mConditions.isDONAttachedMinUpper = isDONAttachedMinUpper; mConditions.isDONCrossedOverMaxUpper = isDONCrossedOverMaxUpper; mConditions.isDONCrossedUnderMaxUpper = isDONCrossedUnderMaxUpper; // // XPV ... // pvHelper.CopyPeak( barIndex, mNumberOfItems, mConditions.pvPeaks // ); pvHelper.CopyVale( barIndex, mNumberOfItems, mConditions.pvVales // ); pvHelper.CopyResistance( barIndex, mNumberOfItems, mConditions.pvResistances // ); pvHelper.CopySupport( barIndex, mNumberOfItems, mConditions.pvSupports // ); pvHelper.CopyFib1( barIndex, mNumberOfItems, mConditions.pvFib1s // ); pvHelper.CopyFib2( barIndex, mNumberOfItems, mConditions.pvFib2s // ); pvHelper.CopyFib3( barIndex, mNumberOfItems, mConditions.pvFib3s // ); pvHelper.CopyFib4( barIndex, mNumberOfItems, mConditions.pvFib4s // ); pvHelper.CopyFib5( barIndex, mNumberOfItems, mConditions.pvFib5s // ); pvHelper.CopySCHH( barIndex, mNumberOfItems, mConditions.pvSCHHs // ); pvHelper.CopySCLL( barIndex, mNumberOfItems, mConditions.pvSCLLs // ); pvHelper.CopyMCHH( barIndex, mNumberOfItems, mConditions.pvMCHHs // ); pvHelper.CopyMCLL( barIndex, mNumberOfItems, mConditions.pvMCLLs // ); pvHelper.CopyLCHH( barIndex, mNumberOfItems, mConditions.pvLCHHs // ); pvHelper.CopyLCLL( barIndex, mNumberOfItems, mConditions.pvLCLLs // ); pvHelper.CopyHCHH( barIndex, mNumberOfItems, mConditions.pvHCHHs // ); pvHelper.CopyHCLL( barIndex, mNumberOfItems, mConditions.pvHCLLs // ); // double pvPeak = mConditions.pvPeaks[curr]; double pvPeakPrev = mConditions.pvPeaks[prev]; // double pvVale = mConditions.pvVales[curr]; double pvValePrev = mConditions.pvVales[prev]; // double pvFib1 = mConditions.pvFib1s[curr]; double pvFib2 = mConditions.pvFib2s[curr]; double pvFib3 = mConditions.pvFib3s[curr]; double pvFib4 = mConditions.pvFib4s[curr]; double pvFib5 = mConditions.pvFib5s[curr]; // double pvFib1Prev = mConditions.pvFib1s[prev]; double pvFib2Prev = mConditions.pvFib2s[prev]; double pvFib3Prev = mConditions.pvFib3s[prev]; double pvFib4Prev = mConditions.pvFib4s[prev]; double pvFib5Prev = mConditions.pvFib5s[prev]; // bool isPVPeakSameAs = IsSame(mConditions.pvPeaks); bool isPVNewPeak = NotEmpty(pvPeak) && pvPeak != pvPeakPrev; bool isPVNewPeakOverLast = isPVNewPeak && pvPeak > pvPeakPrev; bool isPVNewPeakUnderLast = isPVNewPeak && pvPeak < pvPeakPrev; bool isPVValeSameAs = IsSame(mConditions.pvVales); bool isPVNewVale = NotEmpty(pvVale) && pvVale != pvValePrev; bool isPVNewValeOverLast = isPVNewVale && pvVale > pvValePrev; bool isPVNewValeUnderLast = isPVNewVale && pvVale < pvValePrev; bool isPVFiboIncreased = // pvFib1 > pvFib1Prev && pvFib2 > pvFib2Prev && pvFib3 > pvFib3Prev && pvFib4 > pvFib4Prev && pvFib5 > pvFib5Prev // ; bool isPVFiboDecreased = // pvFib1 < pvFib1Prev && pvFib2 < pvFib2Prev && pvFib3 < pvFib3Prev && pvFib4 < pvFib4Prev && pvFib5 < pvFib5Prev // ; bool isPVFiboSectionChanged = // (isPVNewPeakUnderLast && isPVFiboDecreased) // || // (isPVNewValeOverLast && isPVFiboIncreased) // ; // mConditions.isPVPeakSameAs = isPVPeakSameAs; mConditions.isPVNewPeak = isPVNewPeak; mConditions.isPVNewPeakOverLast = isPVNewPeakOverLast; mConditions.isPVNewPeakUnderLast = isPVNewPeakUnderLast; mConditions.isPVValeSameAs = isPVValeSameAs; mConditions.isPVNewVale = isPVNewVale; mConditions.isPVNewValeOverLast = isPVNewValeOverLast; mConditions.isPVNewValeUnderLast = isPVNewValeUnderLast; mConditions.isPVFiboIncreased = isPVFiboIncreased; mConditions.isPVFiboDecreased = isPVFiboDecreased; mConditions.isPVFiboSectionChanged = isPVFiboSectionChanged; // // XPV Cycles ... // double pvSCHH = mConditions.pvSCHHs[curr]; double pvSCLL = mConditions.pvSCLLs[curr]; double pvMCHH = mConditions.pvMCHHs[curr]; double pvMCLL = mConditions.pvMCLLs[curr]; double pvLCHH = mConditions.pvLCHHs[curr]; double pvLCLL = mConditions.pvLCLLs[curr]; double pvHCHH = mConditions.pvHCHHs[curr]; double pvHCLL = mConditions.pvHCLLs[curr]; // double pvSCHHPrev = mConditions.pvSCHHs[prev]; double pvSCLLPrev = mConditions.pvSCLLs[prev]; double pvMCHHPrev = mConditions.pvMCHHs[prev]; double pvMCLLPrev = mConditions.pvMCLLs[prev]; double pvLCHHPrev = mConditions.pvLCHHs[prev]; double pvLCLLPrev = mConditions.pvLCLLs[prev]; double pvHCHHPrev = mConditions.pvHCHHs[prev]; double pvHCLLPrev = mConditions.pvHCLLs[prev]; // double pvSCHHPrevPrev = mConditions.pvSCHHs[prev + 1]; double pvSCLLPrevPrev = mConditions.pvSCLLs[prev + 1]; double pvMCHHPrevPrev = mConditions.pvMCHHs[prev + 1]; double pvMCLLPrevPrev = mConditions.pvMCLLs[prev + 1]; double pvLCHHPrevPrev = mConditions.pvLCHHs[prev + 1]; double pvLCLLPrevPrev = mConditions.pvLCLLs[prev + 1]; double pvHCHHPrevPrev = mConditions.pvHCHHs[prev + 1]; double pvHCLLPrevPrev = mConditions.pvHCLLs[prev + 1]; // // Short ... // bool isPVSCHHBullish = pvSCHH > pvSCHHPrev; bool isPVSCHHBullishPrev = pvSCHHPrev > pvSCHHPrevPrev; bool isPVSCLLBullish = pvSCLL > pvSCLLPrev; bool isPVSCLLBullishPrev = pvSCLLPrev > pvSCLLPrevPrev; bool isPVSCBullish = // isPVSCHHBullish && isPVSCLLBullish // ; bool isPVSCBullishPrev = // isPVSCHHBullishPrev && isPVSCLLBullishPrev // ; bool isPVSCSwitchedToBullish = // isPVSCBullish && !isPVSCBullishPrev // ; // bool isPVSCHHBearish = pvSCHH < pvSCHHPrev; bool isPVSCHHBearishPrev = pvSCHHPrev < pvSCHHPrevPrev; bool isPVSCLLBearish = pvSCLL < pvSCLLPrev; bool isPVSCLLBearishPrev = pvSCLLPrev < pvSCLLPrevPrev; bool isPVSCBearish = // isPVSCHHBearish && isPVSCLLBearish // ; bool isPVSCBearishPrev = // isPVSCHHBearishPrev && isPVSCLLBearishPrev // ; bool isPVSCSwitchedToBearish = // isPVSCBearish && !isPVSCBearishPrev // ; // // Medium ... // bool isPVMCHHBullish = pvMCHH > pvMCHHPrev; bool isPVMCHHBullishPrev = pvMCHHPrev > pvMCHHPrevPrev; bool isPVMCLLBullish = pvMCLL > pvMCLLPrev; bool isPVMCLLBullishPrev = pvMCLLPrev > pvMCLLPrevPrev; bool isPVMCBullish = // isPVMCHHBullish && isPVMCLLBullish // ; bool isPVMCBullishPrev = // isPVMCHHBullishPrev && isPVMCLLBullishPrev // ; bool isPVMCSwitchedToBullish = // isPVMCBullish && !isPVMCBullishPrev // ; // bool isPVMCHHBearish = pvMCHH < pvMCHHPrev; bool isPVMCHHBearishPrev = pvMCHHPrev < pvMCHHPrevPrev; bool isPVMCLLBearish = pvMCLL < pvMCLLPrev; bool isPVMCLLBearishPrev = pvMCLLPrev < pvMCLLPrevPrev; bool isPVMCBearish = // isPVMCHHBearish && isPVMCLLBearish // ; bool isPVMCBearishPrev = // isPVMCHHBearishPrev && isPVMCLLBearishPrev // ; bool isPVMCSwitchedToBearish = // isPVMCBearish && !isPVMCBearishPrev // ; // // Long ... // bool isPVLCHHBullish = pvLCHH > pvLCHHPrev; bool isPVLCHHBullishPrev = pvLCHHPrev > pvLCHHPrevPrev; bool isPVLCLLBullish = pvLCLL > pvLCLLPrev; bool isPVLCLLBullishPrev = pvLCLLPrev > pvLCLLPrevPrev; bool isPVLCBullish = // isPVLCHHBullish && isPVLCLLBullish // ; bool isPVLCBullishPrev = // isPVLCHHBullishPrev && isPVLCLLBullishPrev // ; bool isPVLCSwitchedToBullish = // isPVLCBullish && !isPVLCBullishPrev // ; // bool isPVLCHHBearish = pvLCHH < pvLCHHPrev; bool isPVLCHHBearishPrev = pvLCHHPrev < pvLCHHPrevPrev; bool isPVLCLLBearish = pvLCLL < pvLCLLPrev; bool isPVLCLLBearishPrev = pvLCLLPrev < pvLCLLPrevPrev; bool isPVLCBearish = // isPVLCHHBearish && isPVLCLLBearish // ; bool isPVLCBearishPrev = // isPVLCHHBearishPrev && isPVLCLLBearishPrev // ; bool isPVLCSwitchedToBearish = // isPVLCBearish && !isPVLCBearishPrev // ; // // Hind ... // bool isPVHCHHBullish = pvHCHH > pvHCHHPrev; bool isPVHCHHBullishPrev = pvHCHHPrev > pvHCHHPrevPrev; bool isPVHCLLBullish = pvHCLL > pvHCLLPrev; bool isPVHCLLBullishPrev = pvHCLLPrev > pvHCLLPrevPrev; bool isPVHCBullish = // isPVHCHHBullish && isPVHCLLBullish // ; bool isPVHCBullishPrev = // isPVHCHHBullishPrev && isPVHCLLBullishPrev // ; bool isPVHCSwitchedToBullish = // isPVHCBullish && !isPVHCBullishPrev // ; // bool isPVHCHHBearish = pvHCHH < pvHCHHPrev; bool isPVHCHHBearishPrev = pvHCHHPrev < pvHCHHPrevPrev; bool isPVHCLLBearish = pvHCLL < pvHCLLPrev; bool isPVHCLLBearishPrev = pvHCLLPrev < pvHCLLPrevPrev; bool isPVHCBearish = // isPVHCHHBearish && isPVHCLLBearish // ; bool isPVHCBearishPrev = // isPVHCHHBearishPrev && isPVHCLLBearishPrev // ; bool isPVHCSwitchedToBearish = // isPVHCBearish && !isPVHCBearishPrev // ; // mConditions.isPVSCHHBullish = isPVSCHHBullish; mConditions.isPVSCLLBullish = isPVSCLLBullish; mConditions.isPVSCBullish = isPVSCBullish; mConditions.isPVSCSwitchedToBullish = isPVSCSwitchedToBullish; mConditions.isPVSCHHBearish = isPVSCHHBearish; mConditions.isPVSCLLBearish = isPVSCLLBearish; mConditions.isPVSCBearish = isPVSCBearish; mConditions.isPVSCSwitchedToBearish = isPVSCSwitchedToBearish; mConditions.isPVMCHHBullish = isPVMCHHBullish; mConditions.isPVMCLLBullish = isPVMCLLBullish; mConditions.isPVMCBullish = isPVMCBullish; mConditions.isPVMCSwitchedToBullish = isPVMCSwitchedToBullish; mConditions.isPVMCHHBearish = isPVMCHHBearish; mConditions.isPVMCLLBearish = isPVMCLLBearish; mConditions.isPVMCBearish = isPVMCBearish; mConditions.isPVMCSwitchedToBearish = isPVMCSwitchedToBearish; mConditions.isPVLCHHBullish = isPVLCHHBullish; mConditions.isPVLCLLBullish = isPVLCLLBullish; mConditions.isPVLCBullish = isPVLCBullish; mConditions.isPVLCSwitchedToBullish = isPVLCSwitchedToBullish; mConditions.isPVLCHHBearish = isPVLCHHBearish; mConditions.isPVLCLLBearish = isPVLCLLBearish; mConditions.isPVLCBearish = isPVLCBearish; mConditions.isPVLCSwitchedToBearish = isPVLCSwitchedToBearish; mConditions.isPVHCHHBullish = isPVHCHHBullish; mConditions.isPVHCLLBullish = isPVHCLLBullish; mConditions.isPVHCBullish = isPVHCBullish; mConditions.isPVHCSwitchedToBullish = isPVHCSwitchedToBullish; mConditions.isPVHCHHBearish = isPVHCHHBearish; mConditions.isPVHCLLBearish = isPVHCLLBearish; mConditions.isPVHCBearish = isPVHCBearish; mConditions.isPVHCSwitchedToBearish = isPVHCSwitchedToBearish; // // X121 Cycles Conditions ... // cMarket.GetMarketConditions( mConditions.cMarketConditions, barIndex, mNumberOfItems // ); // sMarket.GetMarketConditions( mConditions.sMarketConditions, barIndex, mNumberOfItems // ); // mMarket.GetMarketConditions( mConditions.mMarketConditions, barIndex, mNumberOfItems // ); // lMarket.GetMarketConditions( mConditions.lMarketConditions, barIndex, mNumberOfItems // ); // hMarket.GetMarketConditions( mConditions.hMarketConditions, barIndex, mNumberOfItems // ); } // // Signalling based On Signallers ... // // X121XSP ... // bool X121XSPHasSpecifiedLongSignal( X121MarketConditions &mConditions // ) { // bool result = false; // return result; } // bool XTESTHasSpecifiedLongSignal( X121MarketConditions &mConditions // ) { // bool result = false; // return result; } // bool X786HasSpecifiedLongSignal( X121MarketConditions &mConditions // ) { // bool result = false; // return result; } // bool XSIHasSpecifiedLongSignal( X121MarketConditions &mConditions // ) { // bool result = false; // return result; } // bool XTSFIHasSpecifiedLongSignal( X121MarketConditions &mConditions // ) { // bool result = false; // return result; } // bool XOBDLHHasSpecifiedLongSignal( X121MarketConditions &mConditions // ) { // bool result = false; // return result; } // bool X121XSPHasSpecifiedShortSignal( X121MarketConditions &mConditions // ) { // bool result = false; // return result; } // bool XTESTHasSpecifiedShortSignal( X121MarketConditions &mConditions // ) { // bool result = false; // return result; } // bool X786HasSpecifiedShortSignal( X121MarketConditions &mConditions // ) { // bool result = false; // return result; } // bool XSIHasSpecifiedShortSignal( X121MarketConditions &mConditions // ) { // bool result = false; // return result; } // bool XTSFIHasSpecifiedShortSignal( X121MarketConditions &mConditions // ) { // bool result = false; // return result; } // bool X92HasSpecifiedShortSignal( X121MarketConditions &mConditions // ) { // bool result = false; // return result; } // }; // // Tools ... // // Model Provider Descriptor ... struct X121ProviderDescriptor { // string symbol; // Trading Symbol ENUM_TIMEFRAMES period; // Trading Timeframe bool allowLong; // Allow Long Signals bool allowShort; // Allow Short Signals ENUM_X121_SIGNAL_PROVIDERS signallers[]; // Allowed Signal Providers // X121ProviderInputs inputs; XSCX121Provider *provider; // XSignal signal; X121MarketConditions conditions; // // Tools ... // bool Init() { // bool result = false; // result = this.Init( this.symbol, this.period, this.signallers, this.allowLong, this.allowShort // ); // return result; } // bool Init( ENUM_X121_SIGNAL_PROVIDERS &mSignallers[], // Allowed Signal Providers bool mAllowLong = true, // Allow Long Signals bool mAllowShort = true // Allow Short Signals ) { // bool result = false; // result = this.Init( this.symbol, this.period, mSignallers, mAllowLong, mAllowShort // ); // return result; } // bool Init( string mSymbol, // Trading Symbol ENUM_TIMEFRAMES mPeriod, // Trading Timeframe ENUM_X121_SIGNAL_PROVIDERS &mSignallers[], // Allowed Signal Providers bool mAllowLong = true, // Allow Long Signals bool mAllowShort = true // Allow Short Signals ) { // bool result = false; // result = // inputs.IsValid() && IsValid(mSymbol) && IsValid(mPeriod) && (allowLong || allowShort) && ArraySize(mSignallers) > 0 // ; if (!result) { return result; } // this.symbol = mSymbol; this.period = mPeriod; this.allowLong = mAllowLong; this.allowShort = mAllowShort; // ENUM_X121_SIGNAL_PROVIDERS tmp[]; Copy( mSignallers, tmp // ); Copy( tmp, this.signallers // ); // // Instantiate Provider ... provider = new XSCX121Provider( this.symbol, this.period // ); // // 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) && (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 GetAllX121SignalProviders(ENUM_X121_SIGNAL_PROVIDERS &result[]) { // Clean(result); // Add(X121NONE, result); Add(X121XSP, result); Add(XTEST, result); Add(X786, result); Add(X121, result); Add(X110, result); Add(X92, result); } // string ToString(ENUM_X121_SIGNAL_PROVIDERS value) { return EnumToString(value); } // ENUM_X121_SIGNAL_PROVIDERS ToX121SignalProvider(string content) { // ENUM_X121_SIGNAL_PROVIDERS result = X121NONE; // if (!IsValid(content)) { return result; } // if (content == ToString(X121NONE)) { result = X121NONE; } else if (content == ToString(X121XSP)) { result = X121XSP; } else if (content == ToString(XTEST)) { result = XTEST; } else if (content == ToString(X786)) { result = X786; } else if (content == ToString(X121)) { result = X121; } else if (content == ToString(X110)) { result = X110; } else if (content == ToString(X92)) { result = X92; } // return result; } //