/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 Helper Class Library // ---------------------------------------------- // Name: XSCXRLHelper // Description: provides all Indicator // Helper requirements ... // // // Maintainer: // ------------ // Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) // ////////////////////////////////////////////////////// // // Global Properties ... #property library #property copyright "Copyright 2023, SaherElm IT Center" #property link "https://www.saherelm.ir" #property version "1.00" #property strict // // Imports ... #include "../Classes/x-saherelm.xhelper.class.mq5" // // Definitions ... // enum ENUM_XRL_STATES { // XRL_STATE_BULLISH = 1, XRL_STATE_BEARISH = -1, }; // enum ENUM_XRL_BUFFERS { // XRL_FAST_LINE = 0, XRL_SLOW_LINE = 2, XRL_VERIFIER_LINE = 2, // XRL_FAST_STATE_LINE = 8, XRL_SLOW_STATE_LINE = 9, XRL_VERIFIER_STATE_LINE = 10, }; // // Input Models ... struct XRLInputs { // // Props ... // // Market ... // Fast ... int fastLength; // Length ENUM_APPLIED_PRICE fastAppliedTo; // Applied To // // Slow ... int slowLength; // Length ENUM_APPLIED_PRICE slowAppliedTo; // Applied To // // Presentation ... bool showFast; // Show Fast bool showSlow; // Show Slow bool showVerifier; // Show Verifier // // Constructor(s) ... XRLInputs() { // Clean(); } // // Tools ... // // Clean ... void Clean() { // fastLength = 0; fastAppliedTo = PRICE_CLOSE; // slowLength = 0; slowAppliedTo = PRICE_CLOSE; // showFast = false; showSlow = false; showVerifier = false; } // // Default ... void Default() { // fastLength = 9; fastAppliedTo = PRICE_CLOSE; // slowLength = 18; slowAppliedTo = PRICE_CLOSE; // showFast = true; showSlow = true; showVerifier = true; } // // Validate ... bool IsValid() { // bool result = false; // result = // fastLength >= 2 && slowLength > fastLength // ; // return result; } // // Retrieve MAx Length ... int Max() { // int result = 0; // result = MathMax(fastLength, slowLength); // return result; } }; // // Define Conditions ... struct XRLConditions { // // Common ... string symbol; ENUM_TIMEFRAMES period; datetime time; // // Buffers ... double fast[]; double fastState[]; double slow[]; double slowState[]; double verifier[]; double verifierState[]; // // Conditions ... // bool isFastBullish; bool isFastBearish; // bool isFastSwitchedToBullish; bool isFastSwitchedToBearish; // bool isSlowBullish; bool isSlowBearish; // bool isSlowSwitchedToBullish; bool isSlowSwitchedToBearish; // bool isFastOverSlow; bool isFastCrossedOverSlow; // bool isFastUnderSlow; bool isFastCrossedUnderSlow; // bool isVerifierBullish; bool isVerifierSwitchedToBullish; // bool isVerifierBearish; bool isVerifierSwitchedToBearish; // void Clean() { // Clean(fast); Clean(slow); Clean(verifier); // Clean(fastState); Clean(slowState); Clean(verifierState); // ArraySetAsSeries(fast, true); ArraySetAsSeries(slow, true); ArraySetAsSeries(verifier, true); // ArraySetAsSeries(fastState, true); ArraySetAsSeries(slowState, true); ArraySetAsSeries(verifierState, true); // isFastBullish = false; isFastBearish = false; isSlowBullish = false; isSlowBearish = false; isFastOverSlow = false; isFastUnderSlow = false; isVerifierBullish = false; isVerifierBearish = false; isFastCrossedOverSlow = false; isFastCrossedUnderSlow = false; isVerifierSwitchedToBullish = false; isVerifierSwitchedToBearish = false; } // void GenerateScore( double &bullishScore, double &bearishScore // ) { // bullishScore = 0; bearishScore = 0; // if (isFastBullish) { bullishScore++; } if (isSlowBullish) { bullishScore++; } if (isFastOverSlow) { bullishScore++; } if (isFastCrossedOverSlow) { bullishScore++; } if (isVerifierBullish) { bullishScore++; } if (isVerifierSwitchedToBullish) { bullishScore++; } // if (isFastBearish) { bearishScore++; } if (isSlowBearish) { bearishScore++; } if (isFastUnderSlow) { bearishScore++; } if (isFastCrossedUnderSlow) { bearishScore++; } if (isVerifierBearish) { bearishScore++; } if (isVerifierSwitchedToBearish) { bearishScore++; } } // string GenerateSummary( bool onlyCommons = false, bool onlyConditions = false, bool includeScores = true, bool ignoreFalseConditions = true, string separator = "\n" // ) { // string result = NULL; // double bullishScore = 0; double bearishScore = 0; GenerateScore( bullishScore, bearishScore // ); // string scoresStr = // "Scores: " + separator + "---------------" + separator + "Bullish: " + ToString(bullishScore) + separator + "Bearish: " + ToString(bearishScore) + separator + "" // ; // string commonStr = GenerateSpecifiedCommonSummary( this, separator, includeScores // ); // string conditionsStr = // ToString("isFastBullish", isFastBullish, ignoreFalseConditions, separator) + ToString("isFastBearish", isFastBearish, ignoreFalseConditions, separator) + ToString("isSlowBullish", isSlowBullish, ignoreFalseConditions, separator) + ToString("isSlowBearish", isSlowBearish, ignoreFalseConditions, separator) + ToString("isFastOverSlow", isFastOverSlow, ignoreFalseConditions, separator) + ToString("isFastCrossedOverSlow", isFastCrossedOverSlow, ignoreFalseConditions, separator) + ToString("isFastUnderSlow", isFastUnderSlow, ignoreFalseConditions, separator) + ToString("isFastCrossedUnderSlow", isFastCrossedUnderSlow, ignoreFalseConditions, separator) + ToString("isVerifierBullish", isVerifierBullish, ignoreFalseConditions, separator) + ToString("isVerifierSwitchedToBullish", isVerifierSwitchedToBullish, ignoreFalseConditions, separator) + ToString("isVerifierBearish", isVerifierBearish, ignoreFalseConditions, separator) + ToString("isVerifierSwitchedToBearish", isVerifierSwitchedToBearish, ignoreFalseConditions, separator) + "" // ; // result = // "[" + GetTag() + "]" + separator + (onlyConditions ? "" : commonStr) + (!includeScores ? "" : scoresStr) + " " + separator + (onlyCommons ? "" : conditionsStr) + "" // ; // return result; } // string GetTag() { return "XRL"; } }; // // Class ... class XSCXRLHelper : public XSCBaseHelper { // // Public ... public: // // Props ... // // Constructors ... XSCXRLHelper() : XSCBaseHelper(_Symbol, _Period) { } // // Deconstructor ... ~XSCXRLHelper() { // Clean(fastBuffer); Clean(slowBuffer); Clean(verifierBuffer); Clean(fastStateBuffer); Clean(slowStateBuffer); Clean(verifierStateBuffer); } // // Tools ... bool Init( string symbol, // Trading Symbol ENUM_TIMEFRAMES period, // Trading Period XRLInputs &inputs // Inputs ) { // bool result = false; // mSymbol = symbol; mPeriod = period; // result = inputs.IsValid(); if (!result) { return result; } // mInputs = inputs; // ArraySetAsSeries(fastBuffer, true); ArraySetAsSeries(slowBuffer, true); ArraySetAsSeries(verifierBuffer, true); // ArraySetAsSeries(fastStateBuffer, true); ArraySetAsSeries(slowStateBuffer, true); ArraySetAsSeries(verifierStateBuffer, true); // mHandler = iCustom( mSymbol, mPeriod, "x-saherelm.xrl", // // Inputs ... // // Market ... "", // // Fast ... "", mInputs.fastLength, mInputs.fastAppliedTo, // // Slow ... "", mInputs.slowLength, mInputs.slowAppliedTo, // // Presentation ... "", mInputs.showFast, mInputs.showSlow, mInputs.showVerifier // ); result = mHandler != INVALID_HANDLE; if (!result) { return result; } // return result; } // // Inputs ... // XRLInputs GetInputs() { return mInputs; } // bool SetInputs( XRLInputs &inputs // Configs ) { // return Init( mSymbol, mPeriod, inputs // ); } // // Buffers ... // // Fast ... // double GetFast( int barIndex // Bar Index ) { // if (barIndex < 0) { barIndex = 0; } // Calculate(); // int count = ArraySize(fastBuffer); if (barIndex >= count) { barIndex = count - 1; } // return fastBuffer[barIndex]; } // // Copy Required Items ... int CopyFast( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool forceClean = true // Force To Clean buffer ) { // // Update Calculations ... Calculate(); // // Copy Items ... return Copy( start, count, fastBuffer, buffer, forceClean // ); } // // Fast State ... // double GetFastState( int barIndex // Bar Index ) { // if (barIndex < 0) { barIndex = 0; } // Calculate(); // int count = ArraySize(fastStateBuffer); if (barIndex >= count) { barIndex = count - 1; } // return fastStateBuffer[barIndex]; } // // Copy Required Items ... int CopyFastState( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool forceClean = true // Force To Clean buffer ) { // // Update Calculations ... Calculate(); // // Copy Items ... return Copy( start, count, fastStateBuffer, buffer, forceClean // ); } // // Slow ... // double GetSlow( int barIndex // Bar Index ) { // if (barIndex < 0) { barIndex = 0; } // Calculate(); // int count = ArraySize(slowBuffer); if (barIndex >= count) { barIndex = count - 1; } // return slowBuffer[barIndex]; } // // Copy Required Items ... int CopySlow( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool forceClean = true // Force To Clean buffer ) { // // Update Calculations ... Calculate(); // // Copy Items ... return Copy( start, count, slowBuffer, buffer, forceClean // ); } // // Slow State ... // double GetSlowState( int barIndex // Bar Index ) { // if (barIndex < 0) { barIndex = 0; } // Calculate(); // int count = ArraySize(slowStateBuffer); if (barIndex >= count) { barIndex = count - 1; } // return slowStateBuffer[barIndex]; } // // Copy Required Items ... int CopySlowState( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool forceClean = true // Force To Clean buffer ) { // // Update Calculations ... Calculate(); // // Copy Items ... return Copy( start, count, slowStateBuffer, buffer, forceClean // ); } // // Verifier ... // double GetVerifier( int barIndex // Bar Index ) { // if (barIndex < 0) { barIndex = 0; } // Calculate(); // int count = ArraySize(verifierBuffer); if (barIndex >= count) { barIndex = count - 1; } // return verifierBuffer[barIndex]; } // // Copy Required Items ... int CopyVerifier( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool forceClean = true // Force To Clean buffer ) { // // Update Calculations ... Calculate(); // // Copy Items ... return Copy( start, count, verifierBuffer, buffer, forceClean // ); } // // Verifier State ... // double GetVerifierState( int barIndex // Bar Index ) { // if (barIndex < 0) { barIndex = 0; } // Calculate(); // int count = ArraySize(verifierStateBuffer); if (barIndex >= count) { barIndex = count - 1; } // return verifierStateBuffer[barIndex]; } // // Copy Required Items ... int CopyVerifierState( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool forceClean = true // Force To Clean buffer ) { // // Update Calculations ... Calculate(); // // Copy Items ... return Copy( start, count, verifierStateBuffer, buffer, forceClean // ); } // bool IsBullish(double state) { // bool result = state == XRL_STATE_BULLISH; // return result; } // bool IsBearish(double state) { // bool result = state == XRL_STATE_BEARISH; // return result; } // // Conditions ... bool GetConditions( XRLConditions &conditions, // int barIndex = 0, // int loopback = 3 // ) { // bool result = true; // if (loopback < 3) { loopback = 3; } // conditions.Clean(); // conditions.symbol = mSymbol; conditions.period = mPeriod; conditions.time = TimeCurrent(); // int zIndex = barIndex; int cIndex = zIndex + 1; int pIndex = cIndex + 1; int ppIndex = pIndex + 1; // // Buffers ... // // Fast ... CopyFast( zIndex, loopback, conditions.fast // ); // // Fast State ... CopyFastState( zIndex, loopback, conditions.fastState // ); // // Slow ... CopySlow( zIndex, loopback, conditions.slow // ); // // Slow State ... CopySlowState( zIndex, loopback, conditions.slowState // ); // // Verifier ... CopyVerifier( zIndex, loopback, conditions.verifier // ); // // Verifier State ... CopyVerifierState( zIndex, loopback, conditions.verifierState // ); // // Conditions ... // bool isFastBullish = IsBullish(conditions.fastState[cIndex]); bool isFastBullishPrev = IsBullish(conditions.fastState[pIndex]); // bool isFastBearish = IsBearish(conditions.fastState[cIndex]); bool isFastBearishPrev = IsBearish(conditions.fastState[pIndex]); // bool isFastSwitchedToBullish = isFastBullish && !isFastBullishPrev; bool isFastSwitchedToBearish = isFastBearish && !isFastBearishPrev; // bool isSlowBullish = IsBullish(conditions.slowState[cIndex]); bool isSlowBullishPrev = IsBullish(conditions.slowState[pIndex]); // bool isSlowBearish = IsBearish(conditions.slowState[cIndex]); bool isSlowBearishPrev = IsBearish(conditions.slowState[pIndex]); // bool isSlowSwitchedToBullish = isSlowBullish && !isSlowBullishPrev; bool isSlowSwitchedToBearish = isSlowBearish && !isSlowBearishPrev; // bool isFastOverSlow = conditions.fast[cIndex] > conditions.slow[cIndex]; bool isFastOverSlowPrev = conditions.fast[pIndex] > conditions.slow[pIndex]; // bool isFastCrossedOverSlow = isFastOverSlow && !isFastOverSlowPrev; // bool isFastUnderSlow = conditions.fast[cIndex] < conditions.slow[cIndex]; bool isFastUnderSlowPrev = conditions.fast[pIndex] < conditions.slow[pIndex]; // bool isFastCrossedUnderSlow = isFastUnderSlow && !isFastUnderSlowPrev; // bool isVerifierBullish = IsBullish(conditions.verifierState[cIndex]); bool isVerifierBullishPrev = IsBullish(conditions.verifierState[pIndex]); // bool isVerifierSwitchedToBullish = isVerifierBullish && !isVerifierBullishPrev; // bool isVerifierBearish = IsBearish(conditions.verifierState[cIndex]); bool isVerifierBearishPrev = IsBearish(conditions.verifierState[pIndex]); // bool isVerifierSwitchedToBearish = isVerifierBearish && !isVerifierBearishPrev; // conditions.isFastBullish = isFastBullish; conditions.isFastBearish = isFastBearish; // conditions.isFastSwitchedToBullish = isFastSwitchedToBullish; conditions.isFastSwitchedToBearish = isFastSwitchedToBearish; // conditions.isSlowBullish = isSlowBullish; conditions.isSlowBearish = isSlowBearish; // conditions.isSlowSwitchedToBullish = isSlowSwitchedToBullish; conditions.isSlowSwitchedToBearish = isSlowSwitchedToBearish; // conditions.isFastOverSlow = isFastOverSlow; conditions.isFastCrossedOverSlow = isFastCrossedOverSlow; // conditions.isFastUnderSlow = isFastUnderSlow; conditions.isFastCrossedUnderSlow = isFastCrossedUnderSlow; // conditions.isVerifierBullish = isVerifierBullish; conditions.isVerifierSwitchedToBullish = isVerifierSwitchedToBullish; // conditions.isVerifierBearish = isVerifierBearish; conditions.isVerifierSwitchedToBearish = isVerifierSwitchedToBearish; // return result; } // // Protected ... protected: // // Private ... private: // // Props ... XRLInputs mInputs; // Inputs ... // // Buffers ... double fastBuffer[]; double fastStateBuffer[]; // double slowBuffer[]; double slowStateBuffer[]; // double verifierBuffer[]; double verifierStateBuffer[]; // // Tools ... // // Calculate Values Until Now ... void Calculate() { // int totalBars = CountBars(); if (totalBars > 1000) { totalBars = 1000; } // // Fast Buffer ... CopyBuffer( mHandler, XRL_FAST_LINE, 0, totalBars, fastBuffer // ); // // Fast State Buffer ... CopyBuffer( mHandler, XRL_FAST_STATE_LINE, 0, totalBars, fastStateBuffer // ); // // Slow Buffer ... CopyBuffer( mHandler, XRL_SLOW_LINE, 0, totalBars, slowBuffer // ); // // Slow State Buffer ... CopyBuffer( mHandler, XRL_SLOW_STATE_LINE, 0, totalBars, slowStateBuffer // ); // // Verifier Buffer ... CopyBuffer( mHandler, XRL_VERIFIER_LINE, 0, totalBars, verifierBuffer // ); // // Verifier State Buffer ... CopyBuffer( mHandler, XRL_VERIFIER_STATE_LINE, 0, totalBars, verifierStateBuffer // ); } }; //