/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 Helper Class Library // ---------------------------------------------- // Name: XCXFIMAHelper // 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.x-helper.class.mq5" #include "../Libraries/x-saherelm.x-poi.extensions.lib.mq5" #include "../Libraries/x-saherelm.x-poi.lib.mq5" // // Definitions ... // // Buffers ... enum ENUM_XFIMA_BUFFERS { XFIMA_MA_FAST_LINE = 0, XFIMA_MA_FAST_COLOR_LINE = 1, XFIMA_MA_FAST_STATE_LINE = 19, XFIMA_MA_SLOW_LINE = 2, XFIMA_MA_SLOW_COLOR_LINE = 3, XFIMA_MA_SLOW_STATE_LINE = 20, XFIMA_SAR_LINE = 4, XFIMA_SAR_COLOR_LINE = 5, XFIMA_SAR_STATE_LINE = 21, XFIMA_PEAK_LINE = 6, XFIMA_VALE_LINE = 7, XFIMA_FIBO_UPPER_LINE = 8, XFIMA_FIBO_MIDDLE_LINE = 9, XFIMA_FIBO_LOWER_LINE = 10, XFIMA_ZIGZAG_LINE = 11, XFIMA_MA_BAND_UPPER_LINE = 12, XFIMA_MA_BAND_LOWER_LINE = 13, XFIMA_ZIGZAG_HIGHS_LINE = 30, XFIMA_ZIGZAG_HIGHS_TIME_LINE = 31, XFIMA_ZIGZAG_LOWS_LINE = 32, XFIMA_ZIGZAG_LOWS_TIME_LINE = 33, // XFIMA_HK_OPEN_LINE = 14, XFIMA_HK_HIGH_LINE = 15, XFIMA_HK_LOW_LINE = 16, XFIMA_HK_CLOSE_LINE = 17, XFIMA_HK_COLOR_LINE = 18, // 19 Ma Fast State // 20 Ma Slow State // 21 Sar State XFIMA_SC_HH_LINE = 22, XFIMA_SC_LL_LINE = 23, XFIMA_MC_HH_LINE = 24, XFIMA_MC_LL_LINE = 25, XFIMA_LC_HH_LINE = 26, XFIMA_LC_LL_LINE = 27, XFIMA_HC_HH_LINE = 28, XFIMA_HC_LL_LINE = 29, // 30 ZigZag Highs // 31 ZigZag Highs Time // 32 ZigZag Lows // 33 ZigZag Lows Time }; // // Input Models ... struct XFIMAInputs { // // Props ... // // Calculation ... ENUM_X_PERIOD_METHOD scMethod; // How to Find Short Period ENUM_TIMEFRAMES scPeriod; // Short Period ENUM_X_PERIOD_METHOD mcMethod; // How to Find Medium Period ENUM_TIMEFRAMES mcPeriod; // Medium Period ENUM_X_PERIOD_METHOD lcMethod; // How to Find Long Period ENUM_TIMEFRAMES lcPeriod; // Long Period ENUM_X_PERIOD_METHOD hcMethod; // How to Find Hind Period ENUM_TIMEFRAMES hcPeriod; // Hind Period ENUM_SERIESMODE upperMode; // Peak Method ENUM_SERIESMODE lowerMode; // Vale Method ENUM_X_FIBO_LEVELS fiboUpperZoneLevel; // Upper Zone Level ENUM_X_FIBO_LEVELS fiboMiddleZoneLevel; // Upper Zone Level ENUM_X_FIBO_LEVELS fiboLowerZoneLevel; // Lower Zone Level double sarStep; // SAR Step double sarMax; // SAR Maximum ENUM_MA_METHOD maMethod; // MA Method ENUM_APPLIED_PRICE maAppliedTo; // MA Applied To int maFastLength; // Fast MA Length int maSlowLength; // Slow MA Length int maBandLength; // MA Band Length int zigzagDepth; // ZigZag Depth int zigzagDeviation; // ZigZag Deviation int zigzagBackStep; // ZigZag Back Step ENUM_X_PRICE zigzagUppersMode; // ZigZag High Detect Mode ENUM_X_PRICE zigzagLowersMode; // ZigZag Low Detect Mode // // Presentation ... bool showPV; // Show PV bool showHK; // Show HK bool showSAR; // Show Sar bool showMAFast; // Show MA Fast bool showMASlow; // Show MA Slow bool showMABand; // Show MA Band bool showZigZag; // Show ZigZag bool showFiboZone; // Show Fibo Zone int startCalculationForLastBars; // Calculate Last n Bars int sarArrowCode; // Parabolic Sar Arrow Code int peakArrowCode; // Peaks Arrow Code int valeArrowCode; // Vales Arrow Code // // Constructor(s) ... XFIMAInputs() { Clean(); } // // Tools ... // // Clean ... void Clean() { ZeroMemory(this); } // // Default ... void Default() { // // Calculations ... scMethod = X_PERIOD_AUTO; // How to Find Short Period scPeriod = NULL; // Short Period mcMethod = X_PERIOD_AUTO; // How to Find Medium Period mcPeriod = NULL; // Medium Period lcMethod = X_PERIOD_AUTO; // How to Find Long Period lcPeriod = NULL; // Long Period hcMethod = X_PERIOD_AUTO; // How to Find Hind Period hcPeriod = NULL; // Hind Period upperMode = MODE_HIGH; // Peak Method lowerMode = MODE_LOW; // Vale Method fiboUpperZoneLevel = X_FIBO_LEVEL_382; // Upper Zone Level fiboMiddleZoneLevel = X_FIBO_LEVEL_500; // Upper Zone Level fiboLowerZoneLevel = X_FIBO_LEVEL_618; // Lower Zone Level sarStep = 0.02; // SAR Step sarMax = 0.2; // SAR Maximum maMethod = MODE_EMA; // MA Method maAppliedTo = PRICE_CLOSE; // MA Applied To maFastLength = 7; // Fast MA Length maSlowLength = 20; // Slow MA Length maBandLength = 7; // MA Band Length zigzagDepth = 12; // ZigZag Depth zigzagDeviation = 5; // ZigZag Deviation zigzagBackStep = 3; // ZigZag Back Step zigzagUppersMode = X_PRICE_HIGH; // ZigZag High Detect Mode zigzagLowersMode = X_PRICE_LOW; // ZigZag Low Detect Mode // // Presentation ... showPV = true; // Show PV showHK = true; // Show HK showSAR = true; // Show Sar showMAFast = true; // Show MA Fast showMASlow = true; // Show MA Slow showMABand = true; // Show MA Band showZigZag = true; // Show ZigZag showFiboZone = true; // Show Fibo Zone startCalculationForLastBars = 1500; // Calculate Last n Bars sarArrowCode = 159; // Parabolic Sar Arrow Code peakArrowCode = 159; // Peaks Arrow Code valeArrowCode = 159; // Vales Arrow Code } // // Hide all Visible Buffers ... void Hide() { // showPV = false; showHK = false; showSAR = false; showMAFast = false; showMASlow = false; showMABand = false; showZigZag = false; showFiboZone = false; } // // Validate ... bool IsValid() { // bool result = false; // result = // // MA ... maFastLength >= 2 && maSlowLength >= 2 && maBandLength >= 2 && maSlowLength > maFastLength && // // SAR ... sarMax > 0 && sarStep > 0 && sarMax > sarStep && // // CYCLES ... (IsSpecifiedValid(scMethod, scPeriod) && IsSpecifiedValid(mcMethod, mcPeriod) && IsSpecifiedValid(lcMethod, lcPeriod) && IsSpecifiedValid(hcMethod, hcPeriod)) && // // ZIGZAG ... zigzagDepth > 0 && zigzagDeviation > 0 && zigzagBackStep > 0 && // // Validate Upper Mode Detection ... IsXValid(zigzagUppersMode) && // // Validate Lower Mode Detection ... IsXValid(zigzagLowersMode) // ; // return result; } }; // // Conditions ... struct XFIMAConditions { // // Common ... string symbol; ENUM_TIMEFRAMES period; datetime time; // datetime to; datetime from; XOHCL bars[]; // // Buffers ... double maFastBuffer[]; double maFastColorBuffer[]; double maFastStateBuffer[]; double maSlowBuffer[]; double maSlowColorBuffer[]; double maSlowStateBuffer[]; double maBandUpperBuffer[]; double maBandLowerBuffer[]; double sarBuffer[]; double sarColorBuffer[]; double sarStateBuffer[]; double peakBuffer[]; double valeBuffer[]; double fiboUpperBuffer[]; double fiboMiddleBuffer[]; double fiboLowerBuffer[]; double zigzagBuffer[]; double sHHBuffer[]; double sLLBuffer[]; double mHHBuffer[]; double mLLBuffer[]; double lHHBuffer[]; double lLLBuffer[]; double hHHBuffer[]; double hLLBuffer[]; double highsBuffer[]; double highsTimeBuffer[]; double lowsBuffer[]; double lowsTimeBuffer[]; double hkOpenBuffer[]; double hkHighBuffer[]; double hkLowBuffer[]; double hkCloseBuffer[]; double hkColorBuffer[]; // // Conditions ... // // Constructor ... XFIMAConditions() { Clean(); } // // Tools ... /** * Cleaning Up ... */ void Clean() { // // Commons ... to = NULL; from = NULL; time = NULL; symbol = NULL; period = NULL; // // Buffers ... // SpecifiedClean(bars); // SpecifiedClean(maFastBuffer); SpecifiedClean(maFastColorBuffer); SpecifiedClean(maFastStateBuffer); SpecifiedClean(maSlowBuffer); SpecifiedClean(maSlowColorBuffer); SpecifiedClean(maSlowStateBuffer); SpecifiedClean(maBandUpperBuffer); SpecifiedClean(maBandLowerBuffer); SpecifiedClean(sarBuffer); SpecifiedClean(sarColorBuffer); SpecifiedClean(sarStateBuffer); SpecifiedClean(peakBuffer); SpecifiedClean(valeBuffer); SpecifiedClean(fiboUpperBuffer); SpecifiedClean(fiboMiddleBuffer); SpecifiedClean(fiboLowerBuffer); SpecifiedClean(zigzagBuffer); SpecifiedClean(sHHBuffer); SpecifiedClean(sLLBuffer); SpecifiedClean(mHHBuffer); SpecifiedClean(mLLBuffer); SpecifiedClean(lHHBuffer); SpecifiedClean(lLLBuffer); SpecifiedClean(hHHBuffer); SpecifiedClean(hLLBuffer); SpecifiedClean(highsBuffer); SpecifiedClean(highsTimeBuffer); SpecifiedClean(lowsBuffer); SpecifiedClean(lowsTimeBuffer); SpecifiedClean(hkOpenBuffer); SpecifiedClean(hkHighBuffer); SpecifiedClean(hkLowBuffer); SpecifiedClean(hkCloseBuffer); SpecifiedClean(hkColorBuffer); // // Conditions ... // ArraySetAsSeries(bars, true); // ArraySetAsSeries(maFastBuffer, true); ArraySetAsSeries(maFastColorBuffer, true); ArraySetAsSeries(maFastStateBuffer, true); ArraySetAsSeries(maSlowBuffer, true); ArraySetAsSeries(maSlowColorBuffer, true); ArraySetAsSeries(maSlowStateBuffer, true); ArraySetAsSeries(maBandUpperBuffer, true); ArraySetAsSeries(maBandLowerBuffer, true); ArraySetAsSeries(sarBuffer, true); ArraySetAsSeries(sarColorBuffer, true); ArraySetAsSeries(sarStateBuffer, true); ArraySetAsSeries(peakBuffer, true); ArraySetAsSeries(valeBuffer, true); ArraySetAsSeries(fiboUpperBuffer, true); ArraySetAsSeries(fiboMiddleBuffer, true); ArraySetAsSeries(fiboLowerBuffer, true); ArraySetAsSeries(zigzagBuffer, false); // Fix this ... ArraySetAsSeries(sHHBuffer, true); ArraySetAsSeries(sLLBuffer, true); ArraySetAsSeries(mHHBuffer, true); ArraySetAsSeries(mLLBuffer, true); ArraySetAsSeries(lHHBuffer, true); ArraySetAsSeries(lLLBuffer, true); ArraySetAsSeries(hHHBuffer, true); ArraySetAsSeries(hLLBuffer, true); ArraySetAsSeries(highsBuffer, true); ArraySetAsSeries(highsTimeBuffer, true); ArraySetAsSeries(lowsBuffer, true); ArraySetAsSeries(lowsTimeBuffer, true); ArraySetAsSeries(hkOpenBuffer, true); ArraySetAsSeries(hkHighBuffer, true); ArraySetAsSeries(hkLowBuffer, true); ArraySetAsSeries(hkCloseBuffer, true); ArraySetAsSeries(hkColorBuffer, true); // ZeroMemory(this); } /** * Generate Conditions Scores ... * * @param bullishScore: Double, Directional Scores Reference ... * @param bearishScore: Double, Directional Scores Reference ... */ void GenerateScore( double &bullishScore, double &bearishScore // ) { } /** * Generate Summary String for Represent Conditions State ... * * @param onlyCommons: Boolean, Just Generate Only Commons Conditions ... * @param onlyConditions: Boolean, Just Generate Only Conditions ... * @param includeScores: Boolean, Attach Scores Representations on Result ... * @param ignoreFalseConditions: Boolean, Ignore False Conditions on Result ... * @param separator: String, Separate Lines ... * * @return ( string ) */ string GenerateSummary( bool onlyCommons = false, bool onlyConditions = false, bool includeScores = true, bool ignoreFalseConditions = true, string separator = "\n" // ) { return ""; } /** * Retrieve Unique Tag Identifier ... * * @return ( string ) */ string GetTag() { return GetToken(this); } }; // // Class ... class XCXFIMAHelper : public XCBaseHelper { // // Public ... public: // // Props ... // // Constructors ... XCXFIMAHelper() : XCBaseHelper(_Symbol, _Period) { } // // Deconstructor ... ~XCXFIMAHelper() { } // // Tools ... // // Initialize Helper Cleass ... bool Init( string symbol, // Trading Symbol ENUM_TIMEFRAMES period, // Trading Period XFIMAInputs &inputs // Inputs ) { // bool result = false; // mSymbol = symbol; mPeriod = period; // result = inputs.IsValid(); if (!result) { return result; } // mInputs = inputs; // mHandler = iCustom( mSymbol, mPeriod, "x-saherelm.xfima", "", // Calculation ... mInputs.scMethod, mInputs.scPeriod, mInputs.mcMethod, mInputs.mcPeriod, mInputs.lcMethod, mInputs.lcPeriod, mInputs.hcMethod, mInputs.hcPeriod, mInputs.upperMode, mInputs.lowerMode, mInputs.fiboUpperZoneLevel, mInputs.fiboMiddleZoneLevel, mInputs.fiboLowerZoneLevel, mInputs.sarStep, mInputs.sarMax, mInputs.maMethod, mInputs.maAppliedTo, mInputs.maFastLength, mInputs.maSlowLength, mInputs.maBandLength, mInputs.zigzagDepth, mInputs.zigzagDeviation, mInputs.zigzagBackStep, mInputs.zigzagUppersMode, mInputs.zigzagLowersMode, "", // Presentation ... mInputs.showPV, mInputs.showHK, mInputs.showSAR, mInputs.showMAFast, mInputs.showMASlow, mInputs.showMABand, mInputs.showZigZag, mInputs.showFiboZone, mInputs.startCalculationForLastBars, mInputs.sarArrowCode, mInputs.peakArrowCode, mInputs.valeArrowCode // ); result = mHandler != INVALID_HANDLE; if (!result) { return result; } // return result; } // // Inputs ... // XFIMAInputs GetInputs() { return mInputs; } // bool SetInputs( XFIMAInputs &inputs // Configs ) { // return Init( mSymbol, mPeriod, inputs // ); } // // Tools ... // bool GetConditions( XFIMAConditions &conditions, // int barIndex = 0, // int loopback = 5 // ) { // bool result = true; // if (loopback < 5) { loopback = 5; } // conditions.Clean(); // conditions.symbol = mSymbol; conditions.period = mPeriod; conditions.time = TimeCurrent(); // // Filling Bars ... int barsCount = GetBars( conditions.bars, mSymbol, mPeriod, barIndex, loopback // ); result = barsCount == loopback; if (!result) { // conditions.Clean(); // return result; } // int zIDX = 0; int cIDX = 1; int pIDX = cIDX + 1; int p2IDX = pIDX + 1; int p3IDX = p2IDX + 1; int p4IDX = p3IDX + 1; // conditions.to = conditions.bars[0].time; conditions.from = conditions.bars[ArraySize(conditions.bars) - 1].time; // int zIndex = barIndex; // // Buffers ... // CopyMAFast( zIndex, loopback, conditions.maFastBuffer // ); // CopyMAFastState( zIndex, loopback, conditions.maFastStateBuffer // ); // CopyMASlow( zIndex, loopback, conditions.maSlowBuffer // ); // CopyMASlowState( zIndex, loopback, conditions.maSlowStateBuffer // ); // CopyMABandUpper( zIndex, loopback, conditions.maBandUpperBuffer // ); // CopyMABandLower( zIndex, loopback, conditions.maBandLowerBuffer // ); // CopySar( zIndex, loopback, conditions.sarBuffer // ); // CopySarState( zIndex, loopback, conditions.sarStateBuffer // ); // CopyPeak( zIndex, loopback, conditions.peakBuffer // ); // CopyVale( zIndex, loopback, conditions.valeBuffer // ); // CopyFiboUpper( zIndex, loopback, conditions.fiboUpperBuffer // ); // CopyFiboMiddle( zIndex, loopback, conditions.fiboMiddleBuffer // ); // CopyFiboLower( zIndex, loopback, conditions.fiboLowerBuffer // ); // CopyZigZag( zIndex, loopback, conditions.zigzagBuffer // ); // CopySHH( zIndex, loopback, conditions.sHHBuffer // ); // CopySLL( zIndex, loopback, conditions.sLLBuffer // ); // CopyMHH( zIndex, loopback, conditions.mHHBuffer // ); // CopyMLL( zIndex, loopback, conditions.mLLBuffer // ); // CopyLHH( zIndex, loopback, conditions.lHHBuffer // ); // CopyLLL( zIndex, loopback, conditions.lLLBuffer // ); // CopyHHH( zIndex, loopback, conditions.hHHBuffer // ); // CopyHLL( zIndex, loopback, conditions.hLLBuffer // ); // CopyHKOpen( zIndex, loopback, conditions.hkOpenBuffer // ); // CopyHKHigh( zIndex, loopback, conditions.hkHighBuffer // ); // CopyHKLow( zIndex, loopback, conditions.hkLowBuffer // ); // CopyHKClose( zIndex, loopback, conditions.hkCloseBuffer // ); // CopyHKColor( zIndex, loopback, conditions.hkColorBuffer // ); // // Conditions ... // return result; } // // Pivot Actions ... /** * Check Specified Bar has MA Cross or not ... * * @param dir: reference for holds cross Direction ... * @param barIndex: int, Specified Bar Index ... * @param validCrossDiffMultiplier: double, validate diff between MAs on Cross happens ... * * @return ( bool ) */ bool HasMACross( ENUM_X_DIRECTION &dir, int barIndex = 0, double validCrossDiffMultiplier = 1 // ) { // bool result = false; // // Prepare ... dir = X_DIRECTION_NONE; // // Normalize ... barIndex = NormalizeInt(barIndex, 0); validCrossDiffMultiplier = NormalizeDouble(validCrossDiffMultiplier, 0); // double fast[]; double slow[]; double upper[]; double lower[]; int count = ReadMAValues( fast, slow, upper, lower, barIndex, 2 // ); // bool isBullish = false; bool isBearish = false; // // Validate Readed Values ... result = IsValidSize(count) && count >= 2; if (result) { // // Detect Direction Change ... // bool notEmpty = NotEmptyZero(fast[0]) && NotEmptyZero(fast[1]) && NotEmptyZero(slow[0]) && NotEmptyZero(slow[1]); // isBullish = notEmpty && fast[0] > slow[0] && fast[1] < slow[1]; // isBearish = notEmpty && fast[0] < slow[0] && fast[1] > slow[1]; // result = isBullish || isBearish; // // Validate Direction Change ... if (result && validCrossDiffMultiplier > 0) { // double _points = GetPoints(GetSymbol()); double diff = MathAbs(fast[0] - slow[0]); // result = diff >= (validCrossDiffMultiplier * _points); } } // if (result) { // // Setting Direction ... dir = isBullish ? X_DIRECTION_BULLISH : isBearish ? X_DIRECTION_BEARISH : X_DIRECTION_NONE; } // // Cleanup Resources ... XClean(fast); XClean(slow); XClean(upper); XClean(lower); // return result; } /** * Check Specified Bar has HK Switch or not ... * * @param dir: reference for holds cross Direction ... * @param barIndex: int, Specified Bar Index ... * * @return ( bool ) */ bool HasHKSwitch( ENUM_X_DIRECTION &dir, int barIndex = 0 // ) { // bool result = false; // // Prepare ... dir = X_DIRECTION_NONE; // // Normalize ... barIndex = NormalizeInt(barIndex, 0); // double low[]; double open[]; double high[]; double close[]; int count = ReadHKBars( open, high, low, close, barIndex, 2 // ); // bool isBullish = false; bool isBearish = false; // // Validate Readed Values ... result = IsValidSize(count) && count >= 2; if (result) { // // Detect Direction Change ... // bool notEmpty = NotEmptyZero(open[0]) && NotEmptyZero(open[1]) && NotEmptyZero(close[0]) && NotEmptyZero(close[1]); // isBullish = notEmpty && open[0] < close[0] && open[1] > close[1]; // isBearish = notEmpty && open[0] > close[0] && open[1] < close[1]; // result = isBullish || isBearish; } // if (result) { // // Setting Direction ... dir = isBullish ? X_DIRECTION_BULLISH : isBearish ? X_DIRECTION_BEARISH : X_DIRECTION_NONE; } // // Cleanup Resources ... XClean(low); XClean(open); XClean(high); XClean(close); // return result; } /** * Check Specified Bar has SAR Switch or not ... * * @param dir: reference for holds cross Direction ... * @param barIndex: int, Specified Bar Index ... * * @return ( bool ) */ bool HasSARSwitch( ENUM_X_DIRECTION &dir, int barIndex = 0 // ) { // bool result = false; // // Prepare ... dir = X_DIRECTION_NONE; // // Normalize ... barIndex = NormalizeInt(barIndex, 0); // // Validate ... result = mHandler != INVALID_HANDLE; if (!result) { return result; } // double sars[]; int count = CopyBuffer( mHandler, XFIMA_SAR_STATE_LINE, barIndex, 2, sars // ); // bool isBullish = false; bool isBearish = false; // // Validate Readed Values ... result = IsValidSize(count) && count >= 2; if (result) { // // Detect Direction Change ... // isBullish = sars[0] >= 1 && sars[1] <= -1; // isBearish = sars[0] <= -1 && sars[1] >= 1; // result = isBullish || isBearish; } // if (result) { // // Setting Direction ... dir = isBullish ? X_DIRECTION_BULLISH : isBearish ? X_DIRECTION_BEARISH : X_DIRECTION_NONE; } // // Cleanup Resources ... XClean(sars); // return result; } /** * Extract Specified Kind of Pivots ... * * @param pivots: XPivot, refrence Collection to hold Extracted pivots ... * @param barIndex: int, Specified Bar Index ... * @param requiredNumberOFPivots: int, Specified which Number of Pivots must be Extracted ... * @param maxAllowedLoopbackLength: int, Specified Maximum Loopback Length for Pivot Extraction ... * @param validationLength: int, Specified Pivots Validation Length ignore if <= 0 ... * * @return ( int ) */ int ExtractPVPivots( XPivot &pivots[], int barIndex = 0, int requiredNumberOFPivots = 50, int maxAllowedLoopbackLength = 1500, int validationLength = 0 // ) { // int result = 0; // // Prepare ... SpecifiedClean(pivots); // // Normalize ... barIndex = NormalizeInt(barIndex, 0); validationLength = NormalizeInt(validationLength, 0); requiredNumberOFPivots = NormalizeInt(requiredNumberOFPivots, 2); maxAllowedLoopbackLength = NormalizeInt(maxAllowedLoopbackLength, 50); // // Validate ... if (mHandler == INVALID_HANDLE) { return result; } // bool lookupPeaks = true; bool lookupVales = true; // XOHCL iBar; XPivot iPivot; bool has = false; int idx = barIndex - 1; int samePeaksCount = 0; int sameValesCount = 0; double tmpPeaksBuffer[]; double tmpValesBuffer[]; string symbol = GetSymbol(); double iPValue = EMPTY_VALUE; double iVValue = EMPTY_VALUE; double pPValue = EMPTY_VALUE; double pVValue = EMPTY_VALUE; ENUM_TIMEFRAMES period = GetPeriod(); ENUM_X_DIRECTION iDir = X_DIRECTION_NONE; ENUM_X_PIVOT_TYPE iType = X_PIVOT_TYPE_NONE; int maxAllowed = barIndex + maxAllowedLoopbackLength - 1; while (idx < maxAllowed && ArraySize(pivots) < requiredNumberOFPivots) { // idx++; // // Prepare ... iBar.Clean(); iPivot.Clean(); SpecifiedClean(tmpPeaksBuffer); SpecifiedClean(tmpValesBuffer); // // Ignore First Item ... if (idx == barIndex) { continue; } // // Initialize Bar ... has = iBar.Init( symbol, period, idx // ); if (!has) { continue; } // // Detecting ... // // Peak ... if (lookupPeaks) { // // Reading Buffer ... CopyBuffer( mHandler, // Handler ... XFIMA_PEAK_LINE, // Handler Buffer Number ... idx, // Bar Index ... 2, // Number of Requirements ... tmpPeaksBuffer // Buffer ... ); ArraySetAsSeries(tmpPeaksBuffer, true); // // Reading Values ... iPValue = tmpPeaksBuffer[0]; pPValue = tmpPeaksBuffer[1]; // // Validate Value ... if (NotEmptyZero(iPValue)) { // // Check New Peak ... has = !NotEmptyZero(pPValue) ? true : iPValue != pPValue; if (has) { // // Calculate and Validate Type ... // Peaks Only Valid when Confirmed by Bar High ... iType = iPValue == iBar.high ? X_PIVOT_TYPE_PEAK : X_PIVOT_TYPE_NONE; has = IsXValid(iType); // // Calculate and Validate Dir ... iDir = IsXPeak(iType) ? X_DIRECTION_BEARISH : X_DIRECTION_NONE; has = has && HasDirection(iDir); // // Check Validation Length ... has = has && (validationLength <= 0 ? true : samePeaksCount >= validationLength); if (has) { // // Initialize and Validate Pivot ... has = iPivot.Init( iPValue, iBar.time, symbol, iDir, period, iType // ); if (has) { // // Add Pivot to Collection only if not Exists ... AddIfNotExists( iPivot, pivots // ); } } // // Cleanup Resources ... iPivot.Clean(); samePeaksCount = 0; } else if (iPValue == pPValue) { samePeaksCount++; } } } // // Vale ... if (lookupVales) { // // Reading Buffer ... CopyBuffer( mHandler, // Handler ... XFIMA_VALE_LINE, // Handler Buffer Number ... idx, // Bar Index ... 2, // Number of Requirements ... tmpValesBuffer // Buffer ... ); ArraySetAsSeries(tmpValesBuffer, true); // // Reading Values ... iVValue = tmpValesBuffer[0]; pVValue = tmpValesBuffer[1]; // // Validate Value ... if (NotEmptyZero(iVValue)) { // // Check New Vale ... has = !NotEmptyZero(pVValue) ? true : iVValue != pVValue; if (has) { // // Calculate and Validate Type ... // Vales Only Valid when Confirmed by Bar Low ... iType = iVValue == iBar.low ? X_PIVOT_TYPE_VALE : X_PIVOT_TYPE_NONE; has = IsXValid(iType); // // Calculate and Validate Dir ... iDir = IsXVale(iType) ? X_DIRECTION_BULLISH : X_DIRECTION_NONE; has = has && HasDirection(iDir); // // Check Validation Length ... has = has && (validationLength <= 0 ? true : sameValesCount >= validationLength); if (has) { // // Initialize and Validate Pivot ... has = iPivot.Init( iVValue, iBar.time, symbol, iDir, period, iType // ); if (has) { // // Add Pivot to Collection only if not Exists ... AddIfNotExists( iPivot, pivots // ); } } // // Cleanup Resources ... iPivot.Clean(); sameValesCount = 0; } else if (iVValue == pVValue) { sameValesCount++; } } } // // Cleanup Resources ... iBar.Clean(); iPivot.Clean(); SpecifiedClean(tmpPeaksBuffer); SpecifiedClean(tmpValesBuffer); // // Check Moving Forward Condition ... has = idx < maxAllowed && ArraySize(pivots) < requiredNumberOFPivots; if (!has) { break; } } // result = ArraySize(pivots); // // Cleanup Resources ... iBar.Clean(); iPivot.Clean(); SpecifiedClean(tmpPeaksBuffer); SpecifiedClean(tmpValesBuffer); // return result; } /** * Extract Specified Kind of Pivots ... * * @param pivots: XPivot, refrence Collection to hold Extracted pivots ... * @param barIndex: int, Specified Bar Index ... * @param requiredNumberOFPivots: int, Specified which Number of Pivots must be Extracted ... * @param validCrossDiffMultiplier: double, validate diff between MAs on Cross happens ... * @param maxAllowedLoopbackLength: int, Specified Maximum Loopback Length for Pivot Extraction ... * * @return ( int ) */ int ExtractMAPivots( XPivot &pivots[], int barIndex = 0, int requiredNumberOFPivots = 50, double validCrossDiffMultiplier = 1, int maxAllowedLoopbackLength = 1500 // ) { // int result = 0; // // Prepare ... SpecifiedClean(pivots); // // Normalize ... barIndex = NormalizeInt(barIndex, 0); requiredNumberOFPivots = NormalizeInt(requiredNumberOFPivots, 2); maxAllowedLoopbackLength = NormalizeInt(maxAllowedLoopbackLength, 50); validCrossDiffMultiplier = NormalizeDouble(validCrossDiffMultiplier, 0); // // Validate ... if (mHandler == INVALID_HANDLE) { return result; } // double fast[]; double slow[]; XPivot iPivot; int count = 0; double upper[]; double lower[]; bool has = false; int idx = barIndex - 1; datetime iPivotTime = NULL; string symbol = GetSymbol(); double iFValue = EMPTY_VALUE; double pFValue = EMPTY_VALUE; double iSValue = EMPTY_VALUE; double pSValue = EMPTY_VALUE; bool isSwitchedToBullish = false; bool isSwitchedToBearish = false; double iSelectedValue = EMPTY_VALUE; ENUM_TIMEFRAMES period = GetPeriod(); ENUM_X_DIRECTION iDir = X_DIRECTION_NONE; ENUM_X_PIVOT_TYPE iType = X_PIVOT_TYPE_NONE; int maxAllowed = barIndex + maxAllowedLoopbackLength - 1; while (idx < maxAllowed && ArraySize(pivots) < requiredNumberOFPivots) { // idx++; // // Prepare ... iPivot.Clean(); SpecifiedClean(fast); SpecifiedClean(slow); SpecifiedClean(upper); SpecifiedClean(lower); // // Ignore First Item ... if (idx == barIndex) { continue; } // // Reading Buffer ... count = ReadMAValues( fast, slow, upper, lower, idx, 2 // ); has = IsValidSize(count); // // Reading Values ... // iFValue = fast[0]; pFValue = fast[1]; // iSValue = slow[0]; pSValue = slow[1]; // // Validate Value ... has = HasMACross( iDir, idx, validCrossDiffMultiplier // ) && NotEmptyZero(iFValue) && NotEmptyZero(iSValue) && NotEmptyZero(pFValue) && NotEmptyZero(pSValue); if (has) { // // Check Direction Changed ... isSwitchedToBullish = IsXBullish(iDir); isSwitchedToBearish = IsXBearish(iDir); has = isSwitchedToBullish || isSwitchedToBearish; if (has) { // // Calculate and Validate Type ... // Peaks Only Valid when Confirmed by Bar High ... iType = isSwitchedToBearish ? X_PIVOT_TYPE_PEAK : isSwitchedToBullish ? X_PIVOT_TYPE_VALE : X_PIVOT_TYPE_NONE; has = IsXValid(iType); // // Calculate and Validate Dir ... iDir = IsXPeak(iType) ? X_DIRECTION_BEARISH : IsXVale(iType) ? X_DIRECTION_BULLISH : X_DIRECTION_NONE; has = has && HasDirection(iDir); // if (has) { // iPivotTime = GetBarTime( symbol, period, idx // ); // // Select Value based on Pivot Type ... iSelectedValue = IsXPeak(iType) ? MathMax(iFValue, iSValue) : MathMin(iFValue, iSValue); // // Initialize and Validate Pivot ... has = iPivot.Init( iSelectedValue, iPivotTime, symbol, iDir, period, iType // ); if (has) { // // Add Pivot to Collection only if not Exists ... AddIfNotExists( iPivot, pivots // ); } } // // Cleanup Resources ... iPivot.Clean(); } } // // Cleanup Resources ... iPivot.Clean(); SpecifiedClean(fast); SpecifiedClean(slow); SpecifiedClean(upper); SpecifiedClean(lower); // // Check Moving Forward Condition ... has = idx < maxAllowed && ArraySize(pivots) < requiredNumberOFPivots; if (!has) { break; } } // result = ArraySize(pivots); // // Cleanup Resources ... iPivot.Clean(); SpecifiedClean(fast); SpecifiedClean(slow); SpecifiedClean(upper); SpecifiedClean(lower); // return result; } /** * Extract Specified Kind of Pivots ... * * @param pivots: XPivot, refrence Collection to hold Extracted pivots ... * @param barIndex: int, Specified Bar Index ... * @param requiredNumberOFPivots: int, Specified which Number of Pivots must be Extracted ... * @param maxAllowedLoopbackLength: int, Specified Maximum Loopback Length for Pivot Extraction ... * * @return ( int ) */ int ExtractHKPivots( XPivot &pivots[], int barIndex = 0, int requiredNumberOFPivots = 50, int maxAllowedLoopbackLength = 1500 // ) { // int result = 0; // // Prepare ... SpecifiedClean(pivots); // // Normalize ... barIndex = NormalizeInt(barIndex, 0); requiredNumberOFPivots = NormalizeInt(requiredNumberOFPivots, 2); maxAllowedLoopbackLength = NormalizeInt(maxAllowedLoopbackLength, 50); // // Validate ... if (mHandler == INVALID_HANDLE) { return result; } // double low[]; double open[]; XPivot iPivot; int count = 0; double high[]; double close[]; bool has = false; int idx = barIndex - 1; datetime iPivotTime = NULL; string symbol = GetSymbol(); bool isSwitchedToBullish = false; bool isSwitchedToBearish = false; double iSelectedValue = EMPTY_VALUE; ENUM_TIMEFRAMES period = GetPeriod(); ENUM_X_DIRECTION iDir = X_DIRECTION_NONE; ENUM_X_PIVOT_TYPE iType = X_PIVOT_TYPE_NONE; int maxAllowed = barIndex + maxAllowedLoopbackLength - 1; while (idx < maxAllowed && ArraySize(pivots) < requiredNumberOFPivots) { // idx++; // // Prepare ... iPivot.Clean(); SpecifiedClean(low); SpecifiedClean(open); SpecifiedClean(high); SpecifiedClean(close); // // Ignore First Item ... if (idx == barIndex) { continue; } // // Reading Buffer ... count = ReadHKBars( open, high, low, close, idx, 2 // ); has = IsValidSize(count); // // Validate Value ... has = HasHKSwitch( iDir, idx // ) && NotEmptyZero(open[0]) && NotEmptyZero(open[1]) && NotEmptyZero(close[0]) && NotEmptyZero(close[1]); if (has) { // // Check Direction Changed ... isSwitchedToBullish = IsXBullish(iDir); isSwitchedToBearish = IsXBearish(iDir); has = isSwitchedToBullish || isSwitchedToBearish; if (has) { // // Calculate and Validate Type ... // Peaks Only Valid when Confirmed by Bar High ... iType = isSwitchedToBearish ? X_PIVOT_TYPE_PEAK : isSwitchedToBullish ? X_PIVOT_TYPE_VALE : X_PIVOT_TYPE_NONE; has = IsXValid(iType); // // Calculate and Validate Dir ... iDir = IsXPeak(iType) ? X_DIRECTION_BEARISH : IsXVale(iType) ? X_DIRECTION_BULLISH : X_DIRECTION_NONE; has = has && HasDirection(iDir); // if (has) { // iPivotTime = GetBarTime( symbol, period, idx // ); // // Select Value based on Pivot Type ... iSelectedValue = IsXPeak(iType) ? MathMax(open[0], close[0]) : MathMin(open[0], close[0]); // // Initialize and Validate Pivot ... has = iPivot.Init( iSelectedValue, iPivotTime, symbol, iDir, period, iType // ); if (has) { // // Add Pivot to Collection only if not Exists ... AddIfNotExists( iPivot, pivots // ); } } // // Cleanup Resources ... iPivot.Clean(); } } // // Cleanup Resources ... iPivot.Clean(); SpecifiedClean(low); SpecifiedClean(open); SpecifiedClean(high); SpecifiedClean(close); // // Check Moving Forward Condition ... has = idx < maxAllowed && ArraySize(pivots) < requiredNumberOFPivots; if (!has) { break; } } // result = ArraySize(pivots); // // Cleanup Resources ... iPivot.Clean(); SpecifiedClean(low); SpecifiedClean(open); SpecifiedClean(high); SpecifiedClean(close); // return result; } /** * Extract Specified Kind of Pivots ... * * @param pivots: XPivot, refrence Collection to hold Extracted pivots ... * @param barIndex: int, Specified Bar Index ... * @param requiredNumberOFPivots: int, Specified which Number of Pivots must be Extracted ... * @param maxAllowedLoopbackLength: int, Specified Maximum Loopback Length for Pivot Extraction ... * * @return ( int ) */ int ExtractSARPivots( XPivot &pivots[], int barIndex = 0, int requiredNumberOFPivots = 50, int maxAllowedLoopbackLength = 1500 // ) { // int result = 0; // // Prepare ... SpecifiedClean(pivots); // // Normalize ... barIndex = NormalizeInt(barIndex, 0); requiredNumberOFPivots = NormalizeInt(requiredNumberOFPivots, 2); maxAllowedLoopbackLength = NormalizeInt(maxAllowedLoopbackLength, 50); // // Validate ... if (mHandler == INVALID_HANDLE) { return result; } // XOHCL iBar; XOHCL pBar; XPivot iPivot; bool has = false; double tmpSarBuffer[]; int idx = barIndex - 1; string symbol = GetSymbol(); double iValue = EMPTY_VALUE; double pValue = EMPTY_VALUE; bool isSwitchedToBullish = false; bool isSwitchedToBearish = false; ENUM_TIMEFRAMES period = GetPeriod(); ENUM_X_DIRECTION iDir = X_DIRECTION_NONE; ENUM_X_PIVOT_TYPE iType = X_PIVOT_TYPE_NONE; int maxAllowed = barIndex + maxAllowedLoopbackLength - 1; while (idx < maxAllowed && ArraySize(pivots) < requiredNumberOFPivots) { // idx++; // // Prepare ... iBar.Clean(); pBar.Clean(); iPivot.Clean(); SpecifiedClean(tmpSarBuffer); // // Ignore First Item ... if (idx == barIndex) { continue; } // // Initialize Bar ... has = iBar.Init( symbol, period, idx // ); has = has && iBar.GetPreviousBar(pBar); if (!has) { continue; } // // Reading Buffer ... CopyBuffer( mHandler, // Handler ... XFIMA_SAR_LINE, // Handler Buffer Number ... idx, // Bar Index ... 2, // Number of Requirements ... tmpSarBuffer // Buffer ... ); ArraySetAsSeries(tmpSarBuffer, true); // // Reading Values ... iValue = tmpSarBuffer[0]; pValue = tmpSarBuffer[1]; // // Validate Value ... if (NotEmptyZero(iValue)) { // // Check Sar Direction Changed ... isSwitchedToBullish = iValue < iBar.low && pValue > pBar.high; isSwitchedToBearish = iValue > iBar.high && pValue < pBar.low; has = isSwitchedToBullish || isSwitchedToBearish; if (has) { // // Calculate and Validate Type ... // Peaks Only Valid when Confirmed by Bar High ... iType = isSwitchedToBearish ? X_PIVOT_TYPE_PEAK : isSwitchedToBullish ? X_PIVOT_TYPE_VALE : X_PIVOT_TYPE_NONE; has = IsXValid(iType); // // Calculate and Validate Dir ... iDir = IsXPeak(iType) ? X_DIRECTION_BEARISH : IsXVale(iType) ? X_DIRECTION_BULLISH : X_DIRECTION_NONE; has = has && HasDirection(iDir); // // TODO: we can also Add other Validations Here ... // if (has) { // // Initialize and Validate Pivot ... has = iPivot.Init( iValue, iBar.time, symbol, iDir, period, iType // ); if (has) { // // Add Pivot to Collection only if not Exists ... AddIfNotExists( iPivot, pivots // ); } } // // Cleanup Resources ... iPivot.Clean(); } } // // Cleanup Resources ... iBar.Clean(); pBar.Clean(); iPivot.Clean(); SpecifiedClean(tmpSarBuffer); // // Check Moving Forward Condition ... has = idx < maxAllowed && ArraySize(pivots) < requiredNumberOFPivots; if (!has) { break; } } // result = ArraySize(pivots); // // Cleanup Resources ... iBar.Clean(); pBar.Clean(); iPivot.Clean(); SpecifiedClean(tmpSarBuffer); // return result; } /** * Extract Specified Kind of Pivots ... * * @param pivots: XPivot, refrence Collection to hold Extracted pivots ... * @param barIndex: int, Specified Bar Index ... * @param requiredNumberOFPivots: int, Specified which Number of Pivots must be Extracted ... * @param maxAllowedLoopbackLength: int, Specified Maximum Loopback Length for Pivot Extraction ... * * @return ( int ) */ int ExtractZigZagPivots( XPivot &pivots[], int barIndex = 0, int requiredNumberOFPivots = 50, int maxAllowedLoopbackLength = 1500 // ) { // int result = 0; // // Prepare ... SpecifiedClean(pivots); // // Normalize ... barIndex = NormalizeInt(barIndex, 0); requiredNumberOFPivots = NormalizeInt(requiredNumberOFPivots, 2); maxAllowedLoopbackLength = NormalizeInt(maxAllowedLoopbackLength, 50); // // Validate ... if (mHandler == INVALID_HANDLE) { return result; } // XOHCL iBar; XPivot iPivot; bool has = false; int idx = barIndex - 1; double tmpZigZagBuffer[]; double iValue = EMPTY_VALUE; string symbol = GetSymbol(); ENUM_TIMEFRAMES period = GetPeriod(); ENUM_X_DIRECTION iDir = X_DIRECTION_NONE; ENUM_X_PIVOT_TYPE iType = X_PIVOT_TYPE_NONE; int maxAllowed = barIndex + maxAllowedLoopbackLength - 1; while (idx < maxAllowed && ArraySize(pivots) < requiredNumberOFPivots) { // idx++; // // Prepare ... iBar.Clean(); iPivot.Clean(); SpecifiedClean(tmpZigZagBuffer); // // Ignore First Item ... if (idx == barIndex) { continue; } // // Initialize Bar ... has = iBar.Init( symbol, period, idx // ); if (!has) { continue; } // // Reading Buffer ... CopyBuffer( mHandler, // Handler ... XFIMA_ZIGZAG_LINE, // Handler Buffer Number ... idx, // Bar Index ... 1, // Number of Requirements ... tmpZigZagBuffer // Buffer ... ); ArraySetAsSeries(tmpZigZagBuffer, true); // // Read and Validate Value ... iValue = tmpZigZagBuffer[0]; has = NotEmptyZero(iValue); if (!has) { // iBar.Clean(); SpecifiedClean(tmpZigZagBuffer); continue; } // // Calculate and Validate Type ... iType = iValue == iBar.high ? X_PIVOT_TYPE_PEAK : iValue == iBar.low ? X_PIVOT_TYPE_VALE : X_PIVOT_TYPE_NONE; has = IsXValid(iType); if (!has) { // iBar.Clean(); SpecifiedClean(tmpZigZagBuffer); continue; } // // Calculate and Validate Dir ... iDir = IsXVale(iType) ? X_DIRECTION_BULLISH : IsXPeak(iType) ? X_DIRECTION_BEARISH : X_DIRECTION_NONE; has = HasDirection(iDir); if (!has) { // iBar.Clean(); SpecifiedClean(tmpZigZagBuffer); continue; } // // Initialize and Validate Pivot ... has = iPivot.Init( iValue, iBar.time, symbol, iDir, period, iType // ); if (has) { // // Add Pivot to Collection only if not Exists ... AddIfNotExists( iPivot, pivots // ); } // // Cleanup Resources ... iBar.Clean(); iPivot.Clean(); SpecifiedClean(tmpZigZagBuffer); // // Check Moving Forward Condition ... has = idx < maxAllowed && ArraySize(pivots) < requiredNumberOFPivots; if (!has) { break; } } // result = ArraySize(pivots); // // Cleanup Resources ... iBar.Clean(); iPivot.Clean(); SpecifiedClean(tmpZigZagBuffer); // return result; } /** * Extract Validated Zones ... * * @param zones: XBoxZone, collection reference to holds results ... * @param barIndex: int, Specified Bar Index ... * @param requiredNumberOFZones: int, required Number of Zones ... * @param breakValidLength: int, Breake Validation Length of Zones ... * @param validateFakeBreakes: bool, Validation Fake Breaked Zones ... * @param shadowMultiplier: double a Shadow Multiplier for Validation ... * @param validationStrength: double, Minimum Strngth Multiplier in Point to Validate ... * @param validationLength: int, Validation Length of Zones ... * @param maxAllowedLoopbackLength: int, max Allowed Loopback Length ... * * @return ( int ) */ int ExtractHKZones( XBoxZone &zones[], int barIndex = 0, int requiredNumberOFZones = 50, int breakValidLength = 3, bool validateFakeBreakes = true, double shadowMultiplier = 3, double validationStrength = 1, int validationLength = 21, int maxAllowedLoopbackLength = 1500 // ) { // int result = 0; // // Prepare ... SpecifiedClean(zones); // // Normalize ... barIndex = NormalizeInt(barIndex, 0); validationLength = NormalizeInt(validationLength, 7); shadowMultiplier = NormalizeDouble(shadowMultiplier, 1); validationStrength = NormalizeDouble(validationStrength, 1); requiredNumberOFZones = NormalizeInt(requiredNumberOFZones, 5); maxAllowedLoopbackLength = NormalizeInt(maxAllowedLoopbackLength, 100); // // Reading Values ... // string symbol = GetSymbol(); ENUM_TIMEFRAMES period = GetPeriod(); double minAllowedStrength = (validationStrength * GetPoints(symbol)); // int count = 0; XBoxZone zone; double hkLows[]; bool has = false; double hkOpens[]; double hkHighs[]; double hkCloses[]; int start = barIndex; bool isBullish = false; bool isBearish = false; double up = EMPTY_VALUE; double down = EMPTY_VALUE; double body = EMPTY_VALUE; double range = EMPTY_VALUE; bool lowShadowPassed = false; bool highShadowPassed = false; double lowShadow = EMPTY_VALUE; double highShadow = EMPTY_VALUE; double startHKLow = EMPTY_VALUE; double startHKOpen = EMPTY_VALUE; double startHKHigh = EMPTY_VALUE; double startHKClose = EMPTY_VALUE; ENUM_X_DIRECTION dir = X_DIRECTION_NONE; int end = start + maxAllowedLoopbackLength; for (int i = start; i < end; i++) { // // Cleanup ... zone.Clean(); dir = X_DIRECTION_NONE; // // Reading HK Buffesr ... count = ReadHKBars( hkOpens, hkHighs, hkLows, hkCloses, i, 1 // ); has = IsValidSize(count); if (!has) { continue; } // // Initialized Start Bar ... if (i == start) { // startHKLow = hkLows[0]; startHKOpen = hkOpens[0]; startHKHigh = hkHighs[0]; startHKClose = hkCloses[0]; } // // Check Direction ... isBullish = hkOpens[0] < hkCloses[0]; isBearish = hkOpens[0] > hkCloses[0]; dir = (isBullish && !isBearish) ? X_DIRECTION_BULLISH : (isBearish && !isBullish) ? X_DIRECTION_BEARISH : X_DIRECTION_NONE; has = HasDirection(dir); if (!has) { continue; } // // Calculate Requirements for Processing ... up = isBullish ? hkCloses[0] : hkOpens[0]; down = isBullish ? hkOpens[0] : hkCloses[0]; body = MathAbs(up - down); range = hkHighs[0] - hkLows[0]; highShadow = hkHighs[0] - up; lowShadow = down - hkLows[0]; // // Detecting Shadows ... // // Low Shadow ... lowShadowPassed = lowShadow >= (shadowMultiplier * highShadow); // // High Shadow ... highShadowPassed = highShadow >= (shadowMultiplier * lowShadow); // has = (lowShadowPassed && !highShadowPassed) || (highShadowPassed && !lowShadowPassed); if (!has) { continue; } // // Filling Zone ... // zone.symbol = symbol; zone.period = period; zone.from = GetBarTime( zone.symbol, zone.period, i // ); zone.dir = lowShadowPassed ? X_DIRECTION_BULLISH : highShadowPassed ? X_DIRECTION_BEARISH : X_DIRECTION_NONE; // zone.upper = IsXBullish(zone.dir) ? down : IsXBearish(zone.dir) ? hkHighs[0] : EMPTY_VALUE; // zone.lower = IsXBullish(zone.dir) ? hkLows[0] : IsXBearish(zone.dir) ? up : EMPTY_VALUE; // zone.to = TimeCurrent(); zone.type = "XHK_" + (IsXBullish(zone.dir) ? "Support" : IsXBearish(zone.dir) ? "Resistance" : "") + "_" + ToXString(TimeToSeconds(zone.from)); // // Validate ... has = zone.IsValid() && HasDirection(zone.dir) && NotEmptyZero(zone.upper) && NotEmptyZero(zone.lower) && (zone.IsBullish() ? startHKLow > zone.upper : startHKHigh < zone.lower) && (zone.upper - zone.lower) >= minAllowedStrength && ValidateHKZone(zone, validationLength, breakValidLength, validateFakeBreakes); if (has) { // AddIfNotExists( zone, zones // ); } // // Cleanup Resources ... zone.Clean(); // // Validating ... result = ArraySize(zones); has = IsValidSize(result) && result >= requiredNumberOFZones; if (has) { break; } } // // Cleanup Resources ... zone.Clean(); SpecifiedClean(hkLows); SpecifiedClean(hkOpens); SpecifiedClean(hkHighs); SpecifiedClean(hkCloses); // return result; } // // Values Retrievers ... // // Fast MA ... // double GetMAFast( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_MA_FAST_LINE, barIndex // ); } // int CopyMAFast( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_MA_FAST_LINE, start, count, asSeries // ); } // // Fast MA State ... // double GetMAFastState( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_MA_FAST_STATE_LINE, barIndex // ); } // int CopyMAFastState( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_MA_FAST_STATE_LINE, start, count, asSeries // ); } // // Slow MA ... // double GetMASlow( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_MA_SLOW_LINE, barIndex // ); } // int CopyMASlow( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_MA_SLOW_LINE, start, count, asSeries // ); } // // Slow MA State ... // double GetMASlowState( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_MA_SLOW_STATE_LINE, barIndex // ); } // int CopyMASlowState( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_MA_SLOW_STATE_LINE, start, count, asSeries // ); } // // Upper MA ... // double GetMABandUpper( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_MA_BAND_UPPER_LINE, barIndex // ); } // int CopyMABandUpper( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_MA_BAND_UPPER_LINE, start, count, asSeries // ); } // // Lower MA ... // double GetMABandLower( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_MA_BAND_LOWER_LINE, barIndex // ); } // int CopyMABandLower( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_MA_BAND_LOWER_LINE, start, count, asSeries // ); } // // SAR ... // double GetSar( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_SAR_LINE, barIndex // ); } // int CopySar( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_SAR_LINE, start, count, asSeries // ); } // // SAR State ... // double GetSarState( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_SAR_STATE_LINE, barIndex // ); } // int CopySarState( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_SAR_STATE_LINE, start, count, asSeries // ); } // // PEAK ... // double GetPeak( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_PEAK_LINE, barIndex // ); } // int CopyPeak( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_PEAK_LINE, start, count, asSeries // ); } // // VALE ... // double GetVale( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_VALE_LINE, barIndex // ); } // int CopyVale( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_VALE_LINE, start, count, asSeries // ); } // // FIBO Zone ... // // FIBO Upper ... // double GetFiboUpper( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_FIBO_UPPER_LINE, barIndex // ); } // int CopyFiboUpper( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_FIBO_UPPER_LINE, start, count, asSeries // ); } // // FIBO Middle ... // double GetFiboMiddle( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_FIBO_MIDDLE_LINE, barIndex // ); } // int CopyFiboMiddle( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_FIBO_MIDDLE_LINE, start, count, asSeries // ); } // // FIBO Lower ... // double GetFiboLower( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_FIBO_LOWER_LINE, barIndex // ); } // int CopyFiboLower( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_FIBO_LOWER_LINE, start, count, asSeries // ); } // // ZigZag ... // double GetZigZag( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_ZIGZAG_LINE, barIndex // ); } // int CopyZigZag( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_ZIGZAG_LINE, start, count, asSeries // ); } // // CYCLES Range ... // // SHORT ... // // HH ... // double GetSHH( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_SC_HH_LINE, barIndex // ); } // int CopySHH( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_SC_HH_LINE, start, count, asSeries // ); } // // LL ... // double GetSLL( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_SC_LL_LINE, barIndex // ); } // int CopySLL( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_SC_LL_LINE, start, count, asSeries // ); } // // MEDIUM ... // // HH ... // double GetMHH( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_MC_HH_LINE, barIndex // ); } // int CopyMHH( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_MC_HH_LINE, start, count, asSeries // ); } // // LL ... // double GetMLL( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_MC_LL_LINE, barIndex // ); } // int CopyMLL( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_MC_LL_LINE, start, count, asSeries // ); } // // LONG ... // // HH ... // double GetLHH( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_LC_HH_LINE, barIndex // ); } // int CopyLHH( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_LC_HH_LINE, start, count, asSeries // ); } // // LL ... // double GetLLL( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_LC_LL_LINE, barIndex // ); } // int CopyLLL( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_LC_LL_LINE, start, count, asSeries // ); } // // HIND ... // // HH ... // double GetHHH( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_HC_HH_LINE, barIndex // ); } // int CopyHHH( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_HC_HH_LINE, start, count, asSeries // ); } // // LL ... // double GetHLL( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_HC_LL_LINE, barIndex // ); } // int CopyHLL( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_HC_LL_LINE, start, count, asSeries // ); } // // XHK ... // // XHK Open ... // double GetHKOpen( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_HK_OPEN_LINE, barIndex // ); } // int CopyHKOpen( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_HK_OPEN_LINE, start, count, asSeries // ); } // // XHK High ... // double GetHKHigh( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_HK_HIGH_LINE, barIndex // ); } // int CopyHKHigh( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_HK_HIGH_LINE, start, count, asSeries // ); } // // XHK Low ... // double GetHKLow( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_HK_LOW_LINE, barIndex // ); } // int CopyHKLow( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_HK_LOW_LINE, start, count, asSeries // ); } // // XHK Close ... // double GetHKClose( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_HK_CLOSE_LINE, barIndex // ); } // int CopyHKClose( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_HK_CLOSE_LINE, start, count, asSeries // ); } // // XHK Color ... // double GetHKColor( int barIndex // Bar Index ) { // return ReadValue( (int)XFIMA_HK_COLOR_LINE, barIndex // ); } // int CopyHKColor( int start, // Start int count, // Number of Items for read double &buffer[], // Dest Buffer bool asSeries = true // As Series Flag ) { // return ReadValues( buffer, (int)XFIMA_HK_COLOR_LINE, start, count, asSeries // ); } // // Protected ... protected: // // Private ... private: // // Props ... XFIMAInputs mInputs; // Inputs ... // // XHK Helper ... // int ReadHKBars( double &open[], double &high[], double &low[], double &close[], int barIndex = 0, int count = 1 // ) { // int result = 0; // // Prepare ... SpecifiedClean(low); SpecifiedClean(open); SpecifiedClean(high); SpecifiedClean(close); // // Normalize ... count = NormalizeInt(count, 1); barIndex = NormalizeInt(barIndex, 0); // // Validate ... if (mHandler == INVALID_HANDLE) { return result; } // // Open ... CopyBuffer( mHandler, XFIMA_HK_OPEN_LINE, barIndex, count, open // ); // // High ... CopyBuffer( mHandler, XFIMA_HK_HIGH_LINE, barIndex, count, high // ); // // Low ... CopyBuffer( mHandler, XFIMA_HK_LOW_LINE, barIndex, count, low // ); // // Close ... CopyBuffer( mHandler, XFIMA_HK_CLOSE_LINE, barIndex, count, close // ); // ArraySetAsSeries(low, true); ArraySetAsSeries(open, true); ArraySetAsSeries(high, true); ArraySetAsSeries(close, true); // // Min Number of Array Sizes ... result = MathMin(ArraySize(open), ArraySize(high)); result = MathMin(result, ArraySize(close)); result = MathMin(result, ArraySize(low)); // return result; } /** * Validate HK Zone ... * * @param zone: XBoxZone, reference to Specified Zone ... * @param validationLength: int, Validation Length of Zones ... * @param breakValidLength: int, Break Validation Length of Zones ... * @param validateFakeBreakes: bool, Validation Fake Breaked Zones ... * * @return ( bool ) */ bool ValidateHKZone( XBoxZone &zone, int validationLength = 1, int breakValidLength = 3, bool validateFakeBreakes = true // ) { // bool result = false; // // Normalize ... validationLength = NormalizeInt(validationLength, 1); breakValidLength = NormalizeInt(breakValidLength, 2); // // Validate ... result = zone.IsValid(); if (!result) { return result; } // // Requirements ... double low[]; double open[]; double high[]; int count = 0; double close[]; // int start = zone.FromIndex() + 1; int end = start + validationLength; // // Validate Before ... for (int i = start; i < end; i++) { // // Reading HK ... count = ReadHKBars( open, high, low, close, i, 1 // ); result = IsValidSize(count); if (!result) { break; } // result = zone.IsBullish() ? low[0] > zone.lower : high[0] < zone.upper; if (!result) { break; } } // // Validating After ... if (result) { // start = zone.ToIndex() + 1; count = zone.FromIndex() - start; end = start + count; for (int i = start; i < end; i++) { // // Reading HK ... count = ReadHKBars( open, high, low, close, i, 1 // ); result = IsValidSize(count); if (!result) { break; } // result = zone.IsBullish() ? low[0] > zone.lower : high[0] < zone.upper; if (!result) { // // Check For Fake Breake ... if (validateFakeBreakes && breakValidLength > 0) { // result = i - 1 >= 0; if (result) { // for (int j = i - 1; j >= zone.ToIndex(); j--) { // // Reading HK ... count = ReadHKBars( open, high, low, close, j, 1 // ); result = IsValidSize(count); if (!result) { break; } // result = zone.IsBullish() ? close[0] > zone.upper : close[0] < zone.lower; if (result) { // result = MathAbs(j - i) <= breakValidLength; if (result) { break; } } } } } // if (!result) { break; } } } } // // Cleanup Resource ... SpecifiedClean(low); SpecifiedClean(open); SpecifiedClean(high); SpecifiedClean(close); // return result; } // int ReadMAValues( double &fast[], double &slow[], double &upper[], double &lower[], int barIndex = 0, int count = 0 // ) { // int result = 0; // // Prepare ... SpecifiedClean(fast); SpecifiedClean(slow); SpecifiedClean(upper); SpecifiedClean(lower); // // Normalize ... count = NormalizeInt(count, 1); barIndex = NormalizeInt(barIndex, 0); // // Validate ... if (mHandler == INVALID_HANDLE) { return result; } // CopyBuffer( mHandler, XFIMA_MA_FAST_LINE, barIndex, count, fast // ); // CopyBuffer( mHandler, XFIMA_MA_SLOW_LINE, barIndex, count, slow // ); // CopyBuffer( mHandler, XFIMA_MA_BAND_UPPER_LINE, barIndex, count, upper // ); // CopyBuffer( mHandler, XFIMA_MA_BAND_LOWER_LINE, barIndex, count, lower // ); // ArraySetAsSeries(fast, true); ArraySetAsSeries(slow, true); ArraySetAsSeries(upper, true); ArraySetAsSeries(lower, true); // result = MathMin(ArraySize(fast), ArraySize(slow)); result = MathMin(result, ArraySize(upper)); result = MathMin(result, ArraySize(lower)); // return result; } // }; //