/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 Indicator // ------------------------------------------------- // Name: X121 // Description: Peaks and Vales ... // // // Maintainer: // ------------ // Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) // ////////////////////////////////////////////////////// // // Global Properties ... #property copyright "Copyright 2023, SaherElm IT Center" #property link "https://saherelm.ir" #property version "1.00" #property description "SaherElm X121 Indicator" #property strict // // Definitions ... // #define ShortName "X121" // // Includes Common Library ... #include "../Classes/x-saherelm.x-poi.class.mq5" #include "../Classes/x-saherelm.x-poi.drawer.class.mq5" #include "../Libraries/x-saherelm.common.lib.mq5" // // Inputs ... // input group "Makret Cycles"; // input group "Short"; input ENUM_X_PERIOD_METHOD scMethod = X_PERIOD_AUTO; // How to Find Period input ENUM_TIMEFRAMES scPeriod = NULL; // Time Period // input group "Medium"; input ENUM_X_PERIOD_METHOD mcMethod = X_PERIOD_AUTO; // How to Find Period input ENUM_TIMEFRAMES mcPeriod = NULL; // Time Period // input group "Long"; input ENUM_X_PERIOD_METHOD lcMethod = X_PERIOD_AUTO; // How to Find Period input ENUM_TIMEFRAMES lcPeriod = NULL; // Time Period // input group "Hind"; input ENUM_X_PERIOD_METHOD hcMethod = X_PERIOD_AUTO; // How to Find Period input ENUM_TIMEFRAMES hcPeriod = NULL; // Time Period // input group "Boundary Detection"; input ENUM_SERIESMODE hhMode = MODE_HIGH; // Highest High Calculation Method input ENUM_SERIESMODE llMode = MODE_LOW; // Lowest Low Calculation Method // input group "Parabolic Sar Detection"; input double sarStep = 0.02; // Step input double sarMax = 0.2; // Maximum // input group "Atr Detection"; input int atrLength = 14; // Length input double atrMultiplier = 1; // Multiplier input ENUM_APPLIED_PRICE atrUpperAppliedTo = PRICE_HIGH; // Upper Zone Applied To input ENUM_APPLIED_PRICE atrLowerAppliedTo = PRICE_LOW; // Lower Zone Applied To input ENUM_X_MA_METHOD atrSmoothingMode = X_MA_MODE_EMA; // Smoothing Method // input group "VWap Detection"; input int vwapFastLength = 20; // Fast Length input int vwapMidLength = 40; // Mid Length input int vwapSlowLength = 60; // Slow Length input ENUM_APPLIED_PRICE vwapAppliedTo = PRICE_CLOSE; // Applied To // input group "Donchain Detection"; input int donchainLength = 40; // Donchain Length // input group "Presentation"; // input int startCalculationForLastBars = 1000; // Calculate Last n Bars // input bool showSar = true; // Show Parabolic Sar input bool showAtr = true; // Show Atr input bool showPeaks = true; // Show Peaks input bool showVales = true; // Show Vales input bool showVWap = true; // Show VWap input bool showDonchain = true; // Show Donchain // input group "Fibonachi Presentation"; input bool showFibo1Levels = false; // Show Fibo 1st Level input bool showFibo2Levels = false; // Show Fibo 2nd Level input bool showFibo3Levels = false; // Show Fibo 3rd Level input bool showFibo4Levels = false; // Show Fibo 4th Level input bool showFibo5Levels = false; // Show Fibo 5th Level // input group "Atr Presentation"; input bool showAtrUpper = true; // Show Upper Zone input bool showAtrLower = true; // Show Lower Zone // input group "VWap Presentation"; input bool showVWapFast = true; // Show VWap Fast input bool showVWapMedium = true; // Show VWap Medium input bool showVWapSlow = true; // Show VWap Slow // input group "Donchain Presentation"; input bool showUpper = true; // Show Upper Band input bool showLower = true; // Show Lower Band input bool showOpen = true; // Show Open input bool showHigh = false; // Show High input bool showClose = true; // Show Close input bool showLow = false; // Show Low // // Non Important Inputs ... // input group "Fibonacci"; input double fiboLevel1 = 0.236; // Fibio 1st Level input double fiboLevel2 = 0.382; // Fibio 2st Level input double fiboLevel3 = 0.5; // Fibio 3rd Level input double fiboLevel4 = 0.618; // Fibio 4th Level input double fiboLevel5 = 0.764; // Fibio 5th Level // input int sarArrowCode = 159; // Parabolic Sar Arrow Code input int peaksArrowCode = 159; // Peaks Arrow Code input int valesArrowCode = 159; // Vales Arrow Code // // Buffers ... // #define hideColorIDX 0 #define bullishColorIDX 1 #define bearishColorIDX 2 #define neuturalColorIDX 3 // #property indicator_chart_window // #property indicator_buffers 42 #property indicator_plots 21 // // PEAKS ... // #define peaksBufferIndex 0 double peaksBuffer[]; // #property indicator_label1 "X121 PEAKS" #property indicator_type1 DRAW_ARROW #property indicator_color1 clrAqua #property indicator_width1 1 // // VALES ... // #define valesBufferIndex 1 double valesBuffer[]; // #property indicator_label2 "X121 VALES" #property indicator_type2 DRAW_ARROW #property indicator_color2 clrMagenta #property indicator_width2 1 // // SAR ... // #define sarBufferIndex 2 double sarBuffer[]; // #property indicator_label3 "X121 SAR" #property indicator_type3 DRAW_ARROW #property indicator_color3 clrYellow #property indicator_width3 1 // // ATR ... // // Upper ... // #define atrUpperBufferIndex 3 double atrUpperBuffer[]; #property indicator_label4 "X121 ATRU" #property indicator_type4 DRAW_LINE #property indicator_color4 clrYellow #property indicator_style4 STYLE_DOT #property indicator_width4 2 // // Lower ... // #define atrLowerBufferIndex 4 double atrLowerBuffer[]; #property indicator_label5 "X121 ATRL" #property indicator_type5 DRAW_LINE #property indicator_color5 clrYellow #property indicator_style5 STYLE_DOT #property indicator_width5 2 // // VWAP ... // // FAST ... #define vwapFastBufferIndex 5 double vwapFastBuffer[]; #define vwapFastColorBufferIndex 6 double vwapFastColorBuffer[]; // #define vwapFastPlotBufferIndex 5 #property indicator_label6 "X121 VWF" #property indicator_type6 DRAW_COLOR_LINE #property indicator_color6 CLR_NONE, clrAqua, clrMagenta, clrGray #property indicator_style6 STYLE_SOLID #property indicator_width6 2 // // MID ... #define vwapMidBufferIndex 7 double vwapMidBuffer[]; #define vwapMidColorBufferIndex 8 double vwapMidColorBuffer[]; // #define vwapMidPlotBufferIndex 6 #property indicator_label7 "X121 VWM" #property indicator_type7 DRAW_COLOR_LINE #property indicator_color7 CLR_NONE, clrGreen, clrRed, clrGray #property indicator_style7 STYLE_SOLID #property indicator_width7 2 // // SLOW ... #define vwapSlowBufferIndex 9 double vwapSlowBuffer[]; #define vwapSlowColorBufferIndex 10 double vwapSlowColorBuffer[]; // #define vwapSlowPlotBufferIndex 7 #property indicator_label8 "X121 VWS" #property indicator_type8 DRAW_COLOR_LINE #property indicator_color8 CLR_NONE, clrSteelBlue, clrDarkRed, clrGray #property indicator_style8 STYLE_SOLID #property indicator_width8 2 // // XDON ... // // Open ... // #define donOpenUpperBufferIndex 11 double donOpenUpperBuffer[]; // #define donOpenUpperPlotBufferIndex 8 #property indicator_label9 "X121 O U" #property indicator_type9 DRAW_LINE #property indicator_color9 clrCornflowerBlue #property indicator_width9 1 // #define donOpenLowerBufferIndex 12 double donOpenLowerBuffer[]; // #define donOpenLowerPlotBufferIndex 9 #property indicator_label10 "X121 O L" #property indicator_type10 DRAW_LINE #property indicator_color10 clrCornflowerBlue #property indicator_width10 1 // // High ... // #define donHighUpperBufferIndex 13 double donHighUpperBuffer[]; // #define donHighUpperPlotBufferIndex 10 #property indicator_label11 "X121 H U" #property indicator_type11 DRAW_LINE #property indicator_color11 clrAquamarine #property indicator_width11 1 // #define donHighLowerBufferIndex 14 double donHighLowerBuffer[]; // #define donHighLowerPlotBufferIndex 11 #property indicator_label12 "X121 H L" #property indicator_type12 DRAW_LINE #property indicator_color12 clrAquamarine #property indicator_width12 1 // // Low ... // #define donLowUpperBufferIndex 15 double donLowUpperBuffer[]; // #define donLowUpperPlotBufferIndex 12 #property indicator_label13 "X121 L U" #property indicator_type13 DRAW_LINE #property indicator_color13 clrDarkOrchid #property indicator_width13 1 // #define donLowLowerBufferIndex 16 double donLowLowerBuffer[]; // #define donLowLowerPlotBufferIndex 13 #property indicator_label14 "X121 L L" #property indicator_type14 DRAW_LINE #property indicator_color14 clrDarkOrchid #property indicator_width14 1 // // Close ... // #define donCloseUpperBufferIndex 17 double donCloseUpperBuffer[]; // #define donCloseUpperPlotBufferIndex 14 #property indicator_label15 "X121 C U" #property indicator_type15 DRAW_LINE #property indicator_color15 clrCoral #property indicator_width15 1 // #define donCloseLowerBufferIndex 18 double donCloseLowerBuffer[]; // #define donCloseLowerPlotBufferIndex 15 #property indicator_label16 "X121 C L" #property indicator_type16 DRAW_LINE #property indicator_color16 clrCoral #property indicator_width16 1 // // FIBONACCI ... // // FIBBO Level 1 ... // #define fl1BufferIndex 19 double fl1Buffer[]; // #define fl1PlotBufferIndex 16 #property indicator_label17 "X121 FL1" #property indicator_type17 DRAW_LINE #property indicator_color17 clrGold #property indicator_style17 STYLE_DASHDOTDOT #property indicator_width17 1 // // FIBBO Level 2 ... // #define fl2BufferIndex 20 double fl2Buffer[]; // #define fl2PlotBufferIndex 17 #property indicator_label18 "X121 FL2" #property indicator_type18 DRAW_LINE #property indicator_color18 clrGold #property indicator_style18 STYLE_DASHDOTDOT #property indicator_width18 1 // // FIBBO Level 3 ... // #define fl3BufferIndex 21 double fl3Buffer[]; // #define fl3PlotBufferIndex 18 #property indicator_label19 "X121 FL3" #property indicator_type19 DRAW_LINE #property indicator_color19 clrGold #property indicator_style19 STYLE_DASHDOTDOT #property indicator_width19 1 // // FIBBO Level 4 ... // #define fl4BufferIndex 22 double fl4Buffer[]; // #define fl4PlotBufferIndex 19 #property indicator_label20 "X121 FL4" #property indicator_type20 DRAW_LINE #property indicator_color20 clrGold #property indicator_style20 STYLE_DASHDOTDOT #property indicator_width20 1 // // FIBBO Level 5 ... // #define fl5BufferIndex 23 double fl5Buffer[]; // #define fl5PlotBufferIndex 20 #property indicator_label21 "X121 FL5" #property indicator_type21 DRAW_LINE #property indicator_color21 clrGold #property indicator_style21 STYLE_DASHDOTDOT #property indicator_width21 1 // // Data Buffers ... // int mLastBufferIndex = 23; // // CURRENT ... // #define cHHBufferIndex mLastBufferIndex + 1 double cHHBuffer[]; // #define cLLBufferIndex mLastBufferIndex + 2 double cLLBuffer[]; // // SHORT ... // #define sHHBufferIndex mLastBufferIndex + 3 double sHHBuffer[]; // #define sLLBufferIndex mLastBufferIndex + 4 double sLLBuffer[]; // // MEDIUM ... // #define mHHBufferIndex mLastBufferIndex + 5 double mHHBuffer[]; // #define mLLBufferIndex mLastBufferIndex + 6 double mLLBuffer[]; // // LONG ... // #define lHHBufferIndex mLastBufferIndex + 7 double lHHBuffer[]; // #define lLLBufferIndex mLastBufferIndex + 8 double lLLBuffer[]; // // HIND ... // #define hHHBufferIndex mLastBufferIndex + 9 double hHHBuffer[]; // #define hLLBufferIndex mLastBufferIndex + 10 double hLLBuffer[]; // // VOLUME ... #define vwapVolumeBufferIndex mLastBufferIndex + 11 double vwapVolumeBuffer[]; // // Price ... #define vwapPriceBufferIndex mLastBufferIndex + 12 double vwapPriceBuffer[]; // // Fast State ... #define vwapFastStateBufferIndex mLastBufferIndex + 13 double vwapFastStateBuffer[]; // // Mid State ... #define vwapMidStateBufferIndex mLastBufferIndex + 14 double vwapMidStateBuffer[]; // // Slow State ... #define vwapSlowStateBufferIndex mLastBufferIndex + 15 double vwapSlowStateBuffer[]; // // ATR ... #define atrBufferIndex mLastBufferIndex + 16 double atrBuffer[]; #define atrUpperRawBufferIndex mLastBufferIndex + 17 double atrUpperRawBuffer[]; #define atrLowerRawBufferIndex mLastBufferIndex + 18 double atrLowerRawBuffer[]; // // Variables, Properties and etc ... // // this counts Available Bars ... int limit; // int maxLength; // // SAR Handler ... int sarHandler = INVALID_HANDLE; // // ATR Handler ... int atrHandler = INVALID_HANDLE; // double mHideColorIDX = 0; // // XMarketCycle sc; int mSCLength = 0; ENUM_TIMEFRAMES mSCPeriod = NULL; // // XMarketCycle mc; int mMCLength = 0; ENUM_TIMEFRAMES mMCPeriod = NULL; // // XMarketCycle lc; int mLCLength = 0; ENUM_TIMEFRAMES mLCPeriod = NULL; // // XMarketCycle hc; int mHCLength = 0; ENUM_TIMEFRAMES mHCPeriod = NULL; // // Event Handlers ... /** * Initialize Indicator ... * * @return ( int ) */ int OnInit() { // // Validate Inputs ... if (!ValidateInputs()) { return INIT_PARAMETERS_INCORRECT; } // // Initialize Indicator Handlers ... // // SAR ... sarHandler = iSAR( _Symbol, _Period, sarStep, sarMax // ); bool isInited = sarHandler != INVALID_HANDLE; if (!isInited) { return INIT_FAILED; } // // ATR ... atrHandler = iATR( _Symbol, _Period, atrLength // ); isInited = atrHandler != INVALID_HANDLE; if (!isInited) { return INIT_FAILED; } // if (!InitMarketCycles()) { return INIT_PARAMETERS_INCORRECT; } // // because in some cases we may have more than one input for // calculation and we must prevent any calculation // untill we pass the biggest input length, here we get max Input length // and then wait until pass it ... maxLength = ExtractMaxLengthOfInputs(); // // Define Index Buffers ... DefineBuffers(); // // Set Indicator ShortName ... SetIndicatorName(); // // Init Succeed ... return INIT_SUCCEEDED; } /** * De Initialize Indicator ... * * @param reason: Integer, De Initialization Reason ... */ void OnDeinit(const int reason) { // // REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function // REASON_REMOVE 1 Program removed from a chart // REASON_RECOMPILE 2 Program recompiled // REASON_CHARTCHANGE 3 A symbol or a chart period is changed // REASON_CHARTCLOSE 4 Chart closed // REASON_PARAMETERS 5 Inputs changed by a user // REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings // REASON_TEMPLATE 7 Another chart template applied // REASON_INITFAILED 8 The OnInit() handler returned a non-zero value // REASON_CLOSE 9 Terminal closed // IndicatorRelease(sarHandler); IndicatorRelease(atrHandler); } /** * Calculate Bars ... * * @param rates_total: Integer, Total Bars on Chart ... * @param prev_calculated: Integer, Total Calculated Bars on Charts ... * @param time: DateTime Array, History of Open Time ... * @param open: Double Array, History of Open Prices ... * @param high: Double Array, History of High Prices ... * @param low: Double Array, History of Low Prices ... * @param close: Double Array, History of Close Prices ... * @param tick_volume: Long, History of Tick Volumes on Bar ... * @param volume: Long, History of Trade Volumes ... * @param spread: Double, History of Spread Price ... * * @return ( int ) */ int OnCalculate( const int rates_total, const int prev_calculated, const datetime &time[], const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], const int &spread[] // ) { // // Prepare Buffers ... ArraySetAsSeries(time, true); ArraySetAsSeries(open, true); ArraySetAsSeries(high, true); ArraySetAsSeries(low, true); ArraySetAsSeries(close, true); ArraySetAsSeries(tick_volume, true); ArraySetAsSeries(volume, true); ArraySetAsSeries(spread, true); // // Fill All Buffers by Zero ... if (prev_calculated == 0) { // ArrayInitialize(peaksBuffer, 0); ArrayInitialize(valesBuffer, 0); ArrayInitialize(sarBuffer, 0); } // // Validate Calculated Bars ... // // SAR ... int sarCalculatedBars = BarsCalculated(sarHandler); // // ATR ... int atrCalculatedBars = BarsCalculated(atrHandler); // bool isPassedRequiredCalculatedBars = // // SAR ... sarCalculatedBars >= maxLength && // // ATR... sarCalculatedBars >= maxLength // ; if (!isPassedRequiredCalculatedBars) { return prev_calculated; } // limit = (prev_calculated > rates_total || prev_calculated <= 0) ? rates_total : (rates_total - prev_calculated) + 1; // // Buffers Copy ... // // SAR ... int copiedSars = CopyBuffer(sarHandler, 0, 0, limit, sarBuffer); // // ATR ... int copiedAtrs = CopyBuffer(atrHandler, 0, 0, limit, atrBuffer); // // Validate Copied Items ... bool isPassedRequiredCopiedItems = // // // SAR ... copiedSars > 0 && copiedAtrs > 0 // ; if (!isPassedRequiredCopiedItems) { return prev_calculated; } // // Main Loop ... for (int i = limit - 1; i >= 0 && !IsStopped(); i--) { // CalculateBuffers( i, prev_calculated, rates_total, // open, high, close, low, tick_volume // ); } // return rates_total; } // // Functions ... /** * Validate Input Args for Initialization ... * * @return ( bool ) */ bool ValidateInputs() { // bool result = // // PSAR ... sarMax > 0 && sarStep > 0 && sarMax > sarStep && // // ATR ... atrLength > 0 && atrMultiplier > 0 && // // XDON ... donchainLength > 0 && // // VWAP ... vwapFastLength > 2 && vwapMidLength > vwapFastLength && vwapSlowLength > vwapMidLength && // // XPV ... (IsValid(scMethod, scPeriod) && IsValid(mcMethod, mcPeriod) && IsValid(lcMethod, lcPeriod) && IsValid(hcMethod, hcPeriod)) // ; // return result; } /** * Extract Max Length of Inputs ... * * @return ( int ) */ int ExtractMaxLengthOfInputs() { // int result = 0; // // XPV ... result = MathMax(mSCLength, mMCLength); result = MathMax(result, mLCLength); result = MathMax(result, mHCLength); // // XVWAP ... result = MathMax(result, vwapFastLength); result = MathMax(result, vwapMidLength); result = MathMax(result, vwapSlowLength); // // ATR ... result = MathMax(result, atrLength); // return result; } /** * Define Required Buffers ... */ void DefineBuffers() { // // PEAKS ... // ENUM_DRAW_TYPE peaksDrawType = showPeaks ? DRAW_ARROW : DRAW_NONE; // ArraySetAsSeries(peaksBuffer, true); SetIndexBuffer(peaksBufferIndex, peaksBuffer, INDICATOR_DATA); // PlotIndexSetInteger(peaksBufferIndex, PLOT_SHOW_DATA, showPeaks); PlotIndexSetInteger(peaksBufferIndex, PLOT_DRAW_TYPE, peaksDrawType); // PlotIndexSetDouble(peaksBufferIndex, PLOT_EMPTY_VALUE, 0); PlotIndexSetInteger(peaksBufferIndex, PLOT_ARROW, peaksArrowCode); // // VALES ... // ENUM_DRAW_TYPE valesDrawType = showVales ? DRAW_ARROW : DRAW_NONE; // ArraySetAsSeries(valesBuffer, true); SetIndexBuffer(valesBufferIndex, valesBuffer, INDICATOR_DATA); // PlotIndexSetInteger(valesBufferIndex, PLOT_SHOW_DATA, showVales); PlotIndexSetInteger(valesBufferIndex, PLOT_DRAW_TYPE, valesDrawType); // PlotIndexSetDouble(valesBufferIndex, PLOT_EMPTY_VALUE, 0); PlotIndexSetInteger(valesBufferIndex, PLOT_ARROW, valesArrowCode); // // SAR ... // ENUM_DRAW_TYPE sarDrawType = showSar ? DRAW_ARROW : DRAW_NONE; // ArraySetAsSeries(sarBuffer, true); SetIndexBuffer(sarBufferIndex, sarBuffer, INDICATOR_DATA); // PlotIndexSetInteger(sarBufferIndex, PLOT_SHOW_DATA, showSar); PlotIndexSetInteger(sarBufferIndex, PLOT_DRAW_TYPE, sarDrawType); // PlotIndexSetDouble(sarBufferIndex, PLOT_EMPTY_VALUE, 0); PlotIndexSetInteger(sarBufferIndex, PLOT_ARROW, sarArrowCode); // // ATR ... // // UPPER ... bool canShowAtrUpper = showAtr && showAtrUpper; ENUM_DRAW_TYPE atrUpperDrawType = canShowAtrUpper ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(atrUpperBuffer, true); SetIndexBuffer(atrUpperBufferIndex, atrUpperBuffer, INDICATOR_DATA); PlotIndexSetDouble(atrUpperBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(atrUpperBufferIndex, PLOT_SHOW_DATA, canShowAtrUpper); PlotIndexSetInteger(atrUpperBufferIndex, PLOT_DRAW_TYPE, atrUpperDrawType); // // LOWER ... bool canShowAtrLower = showAtr && showAtrLower; ENUM_DRAW_TYPE atrLowerDrawType = canShowAtrLower ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(atrLowerBuffer, true); SetIndexBuffer(atrLowerBufferIndex, atrLowerBuffer, INDICATOR_DATA); PlotIndexSetDouble(atrLowerBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(atrLowerBufferIndex, PLOT_SHOW_DATA, canShowAtrLower); PlotIndexSetInteger(atrLowerBufferIndex, PLOT_DRAW_TYPE, atrLowerDrawType); // // XVWAP ... // // Fast ... ArraySetAsSeries(vwapFastBuffer, true); ArraySetAsSeries(vwapFastColorBuffer, true); SetIndexBuffer(vwapFastBufferIndex, vwapFastBuffer, INDICATOR_DATA); SetIndexBuffer(vwapFastColorBufferIndex, vwapFastColorBuffer, INDICATOR_COLOR_INDEX); // // Mid ... ArraySetAsSeries(vwapMidBuffer, true); ArraySetAsSeries(vwapMidColorBuffer, true); SetIndexBuffer(vwapMidBufferIndex, vwapMidBuffer, INDICATOR_DATA); SetIndexBuffer(vwapMidColorBufferIndex, vwapMidColorBuffer, INDICATOR_COLOR_INDEX); // // Slow ... ArraySetAsSeries(vwapSlowBuffer, true); ArraySetAsSeries(vwapSlowColorBuffer, true); SetIndexBuffer(vwapSlowBufferIndex, vwapSlowBuffer, INDICATOR_DATA); SetIndexBuffer(vwapSlowColorBufferIndex, vwapSlowColorBuffer, INDICATOR_COLOR_INDEX); // // XDON ... // // Open ... // // UPPER ... bool canShowCOpenUpper = showDonchain && showUpper && showOpen; ENUM_DRAW_TYPE donOpenUpperDrawType = canShowCOpenUpper ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(donOpenUpperBuffer, true); SetIndexBuffer(donOpenUpperBufferIndex, donOpenUpperBuffer, INDICATOR_DATA); PlotIndexSetDouble(donOpenUpperPlotBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(donOpenUpperPlotBufferIndex, PLOT_SHOW_DATA, canShowCOpenUpper); PlotIndexSetInteger(donOpenUpperPlotBufferIndex, PLOT_DRAW_TYPE, donOpenUpperDrawType); // // LOWER ... bool canShowCOpenLower = showDonchain && showLower && showOpen; ENUM_DRAW_TYPE donOpenLowerDrawType = canShowCOpenLower ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(donOpenLowerBuffer, true); SetIndexBuffer(donOpenLowerBufferIndex, donOpenLowerBuffer, INDICATOR_DATA); PlotIndexSetDouble(donOpenLowerPlotBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(donOpenLowerPlotBufferIndex, PLOT_SHOW_DATA, canShowCOpenLower); PlotIndexSetInteger(donOpenLowerPlotBufferIndex, PLOT_DRAW_TYPE, donOpenLowerDrawType); // // Close ... // // UPPER ... bool canShowCCloseUpper = showDonchain && showUpper && showClose; ENUM_DRAW_TYPE donCloseUpperDrawType = canShowCCloseUpper ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(donCloseUpperBuffer, true); SetIndexBuffer(donCloseUpperBufferIndex, donCloseUpperBuffer, INDICATOR_DATA); PlotIndexSetDouble(donCloseUpperPlotBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(donCloseUpperPlotBufferIndex, PLOT_SHOW_DATA, canShowCCloseUpper); PlotIndexSetInteger(donCloseUpperPlotBufferIndex, PLOT_DRAW_TYPE, donCloseUpperDrawType); // // LOWER ... bool canShowCCloseLower = showDonchain && showLower && showClose; ENUM_DRAW_TYPE donCloseLowerDrawType = canShowCCloseLower ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(donCloseLowerBuffer, true); SetIndexBuffer(donCloseLowerBufferIndex, donCloseLowerBuffer, INDICATOR_DATA); PlotIndexSetDouble(donCloseLowerPlotBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(donCloseLowerPlotBufferIndex, PLOT_SHOW_DATA, canShowCCloseLower); PlotIndexSetInteger(donCloseLowerPlotBufferIndex, PLOT_DRAW_TYPE, donCloseLowerDrawType); // // High ... // // UPPER ... bool canShowCHighUpper = showDonchain && showUpper && showHigh; ENUM_DRAW_TYPE donHighUpperDrawType = canShowCHighUpper ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(donHighUpperBuffer, true); SetIndexBuffer(donHighUpperBufferIndex, donHighUpperBuffer, INDICATOR_DATA); PlotIndexSetDouble(donHighUpperPlotBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(donHighUpperPlotBufferIndex, PLOT_SHOW_DATA, canShowCHighUpper); PlotIndexSetInteger(donHighUpperPlotBufferIndex, PLOT_DRAW_TYPE, donHighUpperDrawType); // // LOWER ... bool canShowCHighLower = showDonchain && showLower && showHigh; ENUM_DRAW_TYPE donHighLowerDrawType = canShowCHighLower ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(donHighLowerBuffer, true); SetIndexBuffer(donHighLowerBufferIndex, donHighLowerBuffer, INDICATOR_DATA); PlotIndexSetDouble(donHighLowerPlotBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(donHighLowerPlotBufferIndex, PLOT_SHOW_DATA, canShowCHighLower); PlotIndexSetInteger(donHighLowerPlotBufferIndex, PLOT_DRAW_TYPE, donHighLowerDrawType); // // Low ... // // UPPER ... bool canShowCLowUpper = showDonchain && showUpper && showLow; ENUM_DRAW_TYPE donLowUpperDrawType = canShowCLowUpper ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(donLowUpperBuffer, true); SetIndexBuffer(donLowUpperBufferIndex, donLowUpperBuffer, INDICATOR_DATA); PlotIndexSetDouble(donLowUpperPlotBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(donLowUpperPlotBufferIndex, PLOT_SHOW_DATA, canShowCLowUpper); PlotIndexSetInteger(donLowUpperPlotBufferIndex, PLOT_DRAW_TYPE, donLowUpperDrawType); // // LOWER ... bool canShowCLowLower = showDonchain && showLower && showLow; ENUM_DRAW_TYPE donLowLowerDrawType = canShowCLowLower ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(donLowLowerBuffer, true); SetIndexBuffer(donLowLowerBufferIndex, donLowLowerBuffer, INDICATOR_DATA); PlotIndexSetDouble(donLowLowerPlotBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(donLowLowerPlotBufferIndex, PLOT_SHOW_DATA, canShowCLowLower); PlotIndexSetInteger(donLowLowerPlotBufferIndex, PLOT_DRAW_TYPE, donLowLowerDrawType); // // FIBONNACI ... // // LEVEL 1 ... bool canShowFl1 = showFibo1Levels; ENUM_DRAW_TYPE fl1DrawType = canShowFl1 ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(fl1Buffer, true); SetIndexBuffer(fl1BufferIndex, fl1Buffer, INDICATOR_DATA); PlotIndexSetDouble(fl1PlotBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(fl1PlotBufferIndex, PLOT_SHOW_DATA, canShowFl1); PlotIndexSetInteger(fl1PlotBufferIndex, PLOT_DRAW_TYPE, fl1DrawType); // // LEVEL 2 ... bool canShowFl2 = showFibo2Levels; ENUM_DRAW_TYPE fl2DrawType = canShowFl2 ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(fl2Buffer, true); SetIndexBuffer(fl2BufferIndex, fl2Buffer, INDICATOR_DATA); PlotIndexSetDouble(fl2PlotBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(fl2PlotBufferIndex, PLOT_SHOW_DATA, canShowFl2); PlotIndexSetInteger(fl2PlotBufferIndex, PLOT_DRAW_TYPE, fl2DrawType); // // LEVEL 3 ... bool canShowFl3 = showFibo3Levels; ENUM_DRAW_TYPE fl3DrawType = canShowFl3 ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(fl3Buffer, true); SetIndexBuffer(fl3BufferIndex, fl3Buffer, INDICATOR_DATA); PlotIndexSetDouble(fl3PlotBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(fl3PlotBufferIndex, PLOT_SHOW_DATA, canShowFl3); PlotIndexSetInteger(fl3PlotBufferIndex, PLOT_DRAW_TYPE, fl3DrawType); // // LEVEL 4 ... bool canShowFl4 = showFibo4Levels; ENUM_DRAW_TYPE fl4DrawType = canShowFl4 ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(fl4Buffer, true); SetIndexBuffer(fl4BufferIndex, fl4Buffer, INDICATOR_DATA); PlotIndexSetDouble(fl4PlotBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(fl4PlotBufferIndex, PLOT_SHOW_DATA, canShowFl4); PlotIndexSetInteger(fl4PlotBufferIndex, PLOT_DRAW_TYPE, fl4DrawType); // // LEVEL 5 ... bool canShowFl5 = showFibo5Levels; ENUM_DRAW_TYPE fl5DrawType = canShowFl5 ? DRAW_LINE : DRAW_NONE; ArraySetAsSeries(fl5Buffer, true); SetIndexBuffer(fl5BufferIndex, fl5Buffer, INDICATOR_DATA); PlotIndexSetDouble(fl5PlotBufferIndex, PLOT_EMPTY_VALUE, EMPTY_VALUE); PlotIndexSetInteger(fl5PlotBufferIndex, PLOT_SHOW_DATA, canShowFl5); PlotIndexSetInteger(fl5PlotBufferIndex, PLOT_DRAW_TYPE, fl5DrawType); // // Data Buffers ... // // CURRENT ... // ArraySetAsSeries(cHHBuffer, true); SetIndexBuffer(cHHBufferIndex, cHHBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(cLLBuffer, true); SetIndexBuffer(cLLBufferIndex, cLLBuffer, INDICATOR_CALCULATIONS); // // SHORT ... // ArraySetAsSeries(sHHBuffer, true); SetIndexBuffer(sHHBufferIndex, sHHBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(sLLBuffer, true); SetIndexBuffer(sLLBufferIndex, sLLBuffer, INDICATOR_CALCULATIONS); // // MEDIUM ... // ArraySetAsSeries(mHHBuffer, true); SetIndexBuffer(mHHBufferIndex, mHHBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(mLLBuffer, true); SetIndexBuffer(mLLBufferIndex, mLLBuffer, INDICATOR_CALCULATIONS); // // LONG ... // ArraySetAsSeries(lHHBuffer, true); SetIndexBuffer(lHHBufferIndex, lHHBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(lLLBuffer, true); SetIndexBuffer(lLLBufferIndex, lLLBuffer, INDICATOR_CALCULATIONS); // // HIND ... // ArraySetAsSeries(hHHBuffer, true); SetIndexBuffer(hHHBufferIndex, hHHBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(hLLBuffer, true); SetIndexBuffer(hLLBufferIndex, hLLBuffer, INDICATOR_CALCULATIONS); // // XVWAP ... // // Volumes ... ArraySetAsSeries(vwapVolumeBuffer, true); SetIndexBuffer(vwapVolumeBufferIndex, vwapVolumeBuffer, INDICATOR_CALCULATIONS); // // Price ... ArraySetAsSeries(vwapPriceBuffer, true); SetIndexBuffer(vwapPriceBufferIndex, vwapPriceBuffer, INDICATOR_CALCULATIONS); // // Fast State ... ArraySetAsSeries(vwapFastStateBuffer, true); SetIndexBuffer(vwapFastStateBufferIndex, vwapFastStateBuffer, INDICATOR_CALCULATIONS); // // Mid State ... ArraySetAsSeries(vwapMidStateBuffer, true); SetIndexBuffer(vwapMidStateBufferIndex, vwapMidStateBuffer, INDICATOR_CALCULATIONS); // // Slow State ... ArraySetAsSeries(vwapSlowStateBuffer, true); SetIndexBuffer(vwapSlowStateBufferIndex, vwapSlowStateBuffer, INDICATOR_CALCULATIONS); // // ATR ... // ArraySetAsSeries(atrBuffer, true); SetIndexBuffer(atrBufferIndex, atrBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(atrUpperRawBuffer, true); SetIndexBuffer(atrUpperRawBufferIndex, atrUpperRawBuffer, INDICATOR_CALCULATIONS); // ArraySetAsSeries(atrLowerRawBuffer, true); SetIndexBuffer(atrLowerRawBufferIndex, atrLowerRawBuffer, INDICATOR_CALCULATIONS); } /** * Set Indicator Short Name and also we can define Buffers Labels ... */ void SetIndicatorName() { IndicatorSetString(INDICATOR_SHORTNAME, ShortName); } /** * Calculate Custom Buffers ... * * @param bar_index: Integer, Represent Current Bar ... * @param prevCalculated: Integer, Represent Previous Calculated Bars ... * @param ratesTotal: Integer, Represents All Available Bars ... * @param open: Double Array, History of Open Prices ... * @param high: Double Array, History of High Prices ... * @param close: Double Array, History of Close Prices ... * @param low: Double Array, History of Low Prices ... * @param tickVolume: Long, History of Tick Volumes on Bar ... */ void CalculateBuffers( int bar_index, // Selected Bar Index const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // int barsLimit = startCalculationForLastBars > 0 ? startCalculationForLastBars : 0; // // bool canCalculate = true; bool canCalculate = barsLimit == 0 || bar_index <= barsLimit; if (canCalculate) { // // Calculate Cycles ... CalculateCycles(bar_index); // // Calculate Peaks and Vales ... CalculatePeaksAndVales(bar_index); // CalculateDonchains( bar_index, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // CalculateAtrZones( bar_index, prevCalculated, ratesTotal, open, high, close, low // ); // CalculateFibonacci( bar_index // ); // // Calculate Required VWAP Data Buffers ... if (ratesTotal - bar_index <= maxLength) { // CalculateVWAPDataBuffers( bar_index, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // // Prevent Moving Forward ... } else { // CalculateVWAPDataBuffers( bar_index, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); // CalculateVWAPS( bar_index, prevCalculated, ratesTotal, open, high, close, low, tickVolume // ); } } else { FillBuffersZero(bar_index); } } // // Custom ... /** * Initial Market Cycles ... * * @return ( bool ) */ bool InitMarketCycles() { // bool result = false; // int cPeriodSeconds = PeriodSeconds(_Period); // // Find Cycle Period ... if (scMethod == X_PERIOD_AUTO) { // // Select Period ... mSCPeriod = GetCyclePeriod( X_MARKET_CYCLE_SHORT, _Period // ); } else { mSCPeriod = scPeriod; } // if (IsValid(mSCPeriod)) { mSCLength = PeriodSeconds(mSCPeriod) / cPeriodSeconds; } // // Find Cycle Period ... if (mcMethod == X_PERIOD_AUTO) { // // Select Period ... mMCPeriod = GetCyclePeriod( X_MARKET_CYCLE_MEDIUM, _Period // ); } else { mMCPeriod = mcPeriod; } // if (IsValid(mMCPeriod)) { mMCLength = PeriodSeconds(mMCPeriod) / cPeriodSeconds; } // // Find Cycle Period ... if (lcMethod == X_PERIOD_AUTO) { // // Select Period ... mLCPeriod = GetCyclePeriod( X_MARKET_CYCLE_LONG, _Period // ); } else { mLCPeriod = lcPeriod; } // if (IsValid(mLCPeriod)) { mLCLength = PeriodSeconds(mLCPeriod) / cPeriodSeconds; } // // Find Cycle Period ... if (hcMethod == X_PERIOD_AUTO) { // // Select Period ... mHCPeriod = GetCyclePeriod( X_MARKET_CYCLE_HIND, _Period // ); } else { mHCPeriod = hcPeriod; } // if (IsValid(mHCPeriod)) { mHCLength = PeriodSeconds(mHCPeriod) / cPeriodSeconds; } // result = mSCLength > 0 && mMCLength > mSCLength && mLCLength > mMCLength && mHCLength > mLCLength; // return result; } /** * Fill All Bufers to Zero Vlue for Specified Bar Index ... * * @param barIndex: Integer ... */ void FillBuffersZero(int barIndex) { // // CURRENT ... cHHBuffer[barIndex] = 0; cLLBuffer[barIndex] = 0; // // SHORT ... sHHBuffer[barIndex] = 0; sLLBuffer[barIndex] = 0; // // MEDIUM ... mHHBuffer[barIndex] = 0; mLLBuffer[barIndex] = 0; // // LONG ... lHHBuffer[barIndex] = 0; lLLBuffer[barIndex] = 0; // // HIND ... hHHBuffer[barIndex] = 0; hLLBuffer[barIndex] = 0; // // PEAKS ... peaksBuffer[barIndex] = 0; // // VALES ... valesBuffer[barIndex] = 0; // // SARS ... sarBuffer[barIndex] = 0; // // ATRS ... atrBuffer[barIndex] = 0; atrUpperBuffer[barIndex] = 0; atrUpperRawBuffer[barIndex] = 0; atrUpperBuffer[barIndex] = 0; atrLowerRawBuffer[barIndex] = 0; // // VWAP ... // vwapFastBuffer[barIndex] = 0; vwapMidBuffer[barIndex] = 0; vwapSlowBuffer[barIndex] = 0; vwapVolumeBuffer[barIndex] = 0; vwapPriceBuffer[barIndex] = 0; // vwapFastColorBuffer[barIndex] = hideColorIDX; vwapMidColorBuffer[barIndex] = hideColorIDX; vwapSlowColorBuffer[barIndex] = hideColorIDX; vwapFastStateBuffer[barIndex] = hideColorIDX; vwapMidStateBuffer[barIndex] = hideColorIDX; vwapSlowStateBuffer[barIndex] = hideColorIDX; // donOpenUpperBuffer[barIndex] = 0; donOpenLowerBuffer[barIndex] = 0; donCloseUpperBuffer[barIndex] = 0; donCloseLowerBuffer[barIndex] = 0; donHighUpperBuffer[barIndex] = 0; donHighLowerBuffer[barIndex] = 0; donLowUpperBuffer[barIndex] = 0; donLowLowerBuffer[barIndex] = 0; // fl1Buffer[barIndex] = 0; fl2Buffer[barIndex] = 0; fl3Buffer[barIndex] = 0; fl4Buffer[barIndex] = 0; fl5Buffer[barIndex] = 0; } /** * Calculate Specified Market Cycle Info ... * * @param barIndex: Integer, Bar Index ... * @param cycle: ENUM_X_MARKET_CYCLES member, Specified Cycle ... * @param hhBuffer: Highest High Buffer Reference ... * @param llBuffer: Lowest Low Buffer Reference ... */ void CalculateCycle( int barIndex, ENUM_X_MARKET_CYCLES cycle, double &hhBuffer[], double &llBuffer[] // ) { // XOHCL bar; bool isBarInited = bar.Init( _Symbol, _Period, barIndex // ); if (!isBarInited) { return; } // int mLength = 0; switch (cycle) { // case X_MARKET_CYCLE_SHORT: mLength = mSCLength; break; // case X_MARKET_CYCLE_MEDIUM: mLength = mMCLength; break; // case X_MARKET_CYCLE_LONG: mLength = mLCLength; break; // case X_MARKET_CYCLE_HIND: mLength = mHCLength; break; } // if (mLength == 0) { return; } // // Find Highest High ... double hhValue = bar.FindHighest( mLength, hhMode // ); hhBuffer[barIndex] = hhValue; // // Find Lowest Low ... double llValue = bar.FindLowest( mLength, llMode // ); llBuffer[barIndex] = llValue; } /** * Claculate Cycles ... * * @param barIndex: Integer, Bar Index ... */ void CalculateCycles(int barIndex) { // // SHORT ... CalculateCycle( barIndex, X_MARKET_CYCLE_SHORT, sHHBuffer, sLLBuffer // ); // // MEDIUM ... CalculateCycle( barIndex, X_MARKET_CYCLE_MEDIUM, mHHBuffer, mLLBuffer // ); // // LONG ... CalculateCycle( barIndex, X_MARKET_CYCLE_LONG, lHHBuffer, lLLBuffer // ); // // HIND ... CalculateCycle( barIndex, X_MARKET_CYCLE_HIND, hHHBuffer, hLLBuffer // ); } /** * Calculate Peaks and Vales ... * * @param barIndex: Integer, Bar Index ... */ void CalculatePeaksAndVales(int barIndex) { // int lastIndex = barIndex + 1; int barsCount = iBars(_Symbol, _Period); // // PEAKS ... double lastPeak = lastIndex < barsCount ? peaksBuffer[lastIndex] : 0; // double isHH = sHHBuffer[barIndex]; double imHH = mHHBuffer[barIndex]; double ilHH = lHHBuffer[barIndex]; double ihHH = hHHBuffer[barIndex]; // double iHHs[4] = { isHH, imHH, ilHH, ihHH // }; double rValue = GetAverage(iHHs); bool isPeak = rValue == isHH && isHH == imHH && imHH == ilHH && ilHH == ihHH; double iPeak = isPeak ? rValue : lastPeak; peaksBuffer[barIndex] = iPeak; // // VALES ... double lastVale = lastIndex < barsCount ? valesBuffer[lastIndex] : 0; // double isLL = sLLBuffer[barIndex]; double imLL = mLLBuffer[barIndex]; double ilLL = lLLBuffer[barIndex]; double ihLL = hLLBuffer[barIndex]; // double iLLs[4] = { isLL, imLL, ilLL, ihLL // }; double sValue = GetAverage(iLLs); bool isVale = sValue == isLL && isLL == imLL && imLL == ilLL && ilLL == ihLL; double iVale = isVale ? sValue : lastVale; valesBuffer[barIndex] = iVale; } /** * Calculate VWAP Value for Specified Bar ... * * @param bar_index: Integer, Represent Current Bar ... * @param prevCalculated: Integer, Represent Previous Calculated Bars ... * @param ratesTotal: Integer, Represents All Available Bars ... * @param open: Double Array, History of Open Prices ... * @param high: Double Array, History of High Prices ... * @param close: Double Array, History of Close Prices ... * @param low: Double Array, History of Low Prices ... * @param tickVolume: Long, History of Tick Volumes on Bar ... * @param _length: Integer, Specified VWAP Length ... * @param _show: Boolean, Specified Show Buffer or not ... * @param _buffer: Double Array Reference, Points to Buffer ... * @param _colorBuffer: Double Array Reference, Points to Color Buffer ... * @param _stateBuffer: Double Array Reference, Points to State Buffer ... */ void CalculateVWAP( int bar_index, // Selected Bar Index const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[], // int _length, // Calculation Length bool _show, double &_buffer[], double &_colorBuffer[], double &_stateBuffer[] // ) { // double vSum = 0; double pSum = 0; double mSum = 0; for (int x = 0; x < _length; x++) { // pSum += vwapPriceBuffer[x + bar_index]; vSum += vwapVolumeBuffer[x + bar_index]; mSum += vwapPriceBuffer[x + bar_index] * vwapVolumeBuffer[x + bar_index]; } // double iValue = mSum / vSum; iValue = NormalizeDouble(iValue, _Digits); // _buffer[bar_index] = iValue; // bool isBullish = low[bar_index] > iValue; bool isBearish = high[bar_index] < iValue; // double iColor = isBullish ? bullishColorIDX : isBearish ? bearishColorIDX : neuturalColorIDX; // _colorBuffer[bar_index] = hideColorIDX; _stateBuffer[bar_index] = iColor; if (showVWap && _show) { _colorBuffer[bar_index] = iColor; } } /** * Calculate Donchain ... * * @param bar_index: Integer, Bar Index ... * @param prevCalculated: Integer, Represent Previous Calculated Bars ... * @param ratesTotal: Integer, Represents All Available Bars ... * @param open: Double Array, History of Open Prices ... * @param high: Double Array, History of High Prices ... * @param close: Double Array, History of Close Prices ... * @param low: Double Array, History of Low Prices ... * @param tickVolume: Long, History of Tick Volumes on Bar ... * @param _length: Integer, Donchain Length ... * @param _ouBuffer: Double Array Reference ... * @param _olBuffer: Double Array Reference ... * @param _huBuffer: Double Array Reference ... * @param _hlBuffer: Double Array Reference ... * @param _luBuffer: Double Array Reference ... * @param _llBuffer: Double Array Reference ... * @param _cuBuffer: Double Array Reference ... * @param _clBuffer: Double Array Reference ... */ void CalculateDonchain( int bar_index, // Selected Bar Index const int prevCalculated, const int ratesTotal, // const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[], // int _length, // double &_ouBuffer[], double &_olBuffer[], double &_huBuffer[], double &_hlBuffer[], double &_luBuffer[], double &_llBuffer[], double &_cuBuffer[], double &_clBuffer[] // ) { // double iUpper = 0; double iLower = 0; // // OPEN ... // int from = bar_index; // iUpper = open[ArrayMaximum(open, from, _length)]; iLower = open[ArrayMinimum(open, from, _length)]; // _ouBuffer[bar_index] = iUpper; _olBuffer[bar_index] = iLower; // // HIGH ... // iUpper = high[ArrayMaximum(high, from, _length)]; iLower = high[ArrayMinimum(high, from, _length)]; // _huBuffer[bar_index] = iUpper; _hlBuffer[bar_index] = iLower; // // LOW ... // iUpper = low[ArrayMaximum(low, from, _length)]; iLower = low[ArrayMinimum(low, from, _length)]; // _luBuffer[bar_index] = iUpper; _llBuffer[bar_index] = iLower; // // CLOSE ... // iUpper = close[ArrayMaximum(close, from, _length)]; iLower = close[ArrayMinimum(close, from, _length)]; // _cuBuffer[bar_index] = iUpper; _clBuffer[bar_index] = iLower; } /** * Calculate VWAP Required Data Buffers ... * * @param bar_index: Integer, Represent Current Bar ... * @param prevCalculated: Integer, Represent Previous Calculated Bars ... * @param ratesTotal: Integer, Represents All Available Bars ... * @param open: Double Array, History of Open Prices ... * @param high: Double Array, History of High Prices ... * @param close: Double Array, History of Close Prices ... * @param low: Double Array, History of Low Prices ... * @param tickVolume: Long, History of Tick Volumes on Bar ... */ void CalculateVWAPDataBuffers( int bar_index, // Selected Bar Index const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // double price = GetAppliedPrice( vwapAppliedTo, open, high, low, close, bar_index // ); vwapPriceBuffer[bar_index] = price; vwapVolumeBuffer[bar_index] = (double)tickVolume[bar_index]; } /** * Calculate Different VWaps ... * * @param bar_index: Integer, Represent Current Bar ... * @param prevCalculated: Integer, Represent Previous Calculated Bars ... * @param ratesTotal: Integer, Represents All Available Bars ... * @param open: Double Array, History of Open Prices ... * @param high: Double Array, History of High Prices ... * @param close: Double Array, History of Close Prices ... * @param low: Double Array, History of Low Prices ... * @param tickVolume: Long, History of Tick Volumes on Bar ... */ void CalculateVWAPS( int bar_index, // Selected Bar Index const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // // Fast ... CalculateVWAP( bar_index, prevCalculated, ratesTotal, open, high, close, low, tickVolume, // vwapFastLength, showVWapFast, vwapFastBuffer, vwapFastColorBuffer, vwapFastStateBuffer // ); // // Mid ... CalculateVWAP( bar_index, prevCalculated, ratesTotal, open, high, close, low, tickVolume, // vwapMidLength, showVWapMedium, vwapMidBuffer, vwapMidColorBuffer, vwapMidStateBuffer // ); // // Fast ... CalculateVWAP( bar_index, prevCalculated, ratesTotal, open, high, close, low, tickVolume, // vwapSlowLength, showVWapSlow, vwapSlowBuffer, vwapSlowColorBuffer, vwapSlowStateBuffer // ); } /** * Calculate Different VWaps ... * * @param bar_index: Integer, Represent Current Bar ... * @param prevCalculated: Integer, Represent Previous Calculated Bars ... * @param ratesTotal: Integer, Represents All Available Bars ... * @param open: Double Array, History of Open Prices ... * @param high: Double Array, History of High Prices ... * @param close: Double Array, History of Close Prices ... * @param low: Double Array, History of Low Prices ... * @param tickVolume: Long, History of Tick Volumes on Bar ... */ void CalculateDonchains( int bar_index, // Selected Bar Index const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[], const long &tickVolume[] // ) { // CalculateDonchain( // bar_index, prevCalculated, ratesTotal, // open, high, close, low, tickVolume, // donchainLength, // donOpenUpperBuffer, donOpenLowerBuffer, donHighUpperBuffer, donHighLowerBuffer, donLowUpperBuffer, donLowLowerBuffer, donCloseUpperBuffer, donCloseLowerBuffer // ); } /** * Calculate Different VWaps ... * * @param bar_index: Integer, Represent Current Bar ... * @param prevCalculated: Integer, Represent Previous Calculated Bars ... * @param ratesTotal: Integer, Represents All Available Bars ... * @param open: Double Array, History of Open Prices ... * @param high: Double Array, History of High Prices ... * @param close: Double Array, History of Close Prices ... * @param low: Double Array, History of Low Prices ... */ void CalculateAtrZones( int bar_index, // Selected Bar Index const int prevCalculated, const int ratesTotal, const double &open[], const double &high[], const double &close[], const double &low[] // ) { // // Select ATr Value ... double atrValue = atrBuffer[bar_index]; double appliedAtrMultiplierValue = atrValue * atrMultiplier; // // Select Upper Price ... double upperPrice = GetAppliedPrice( atrUpperAppliedTo, open, high, low, close, bar_index // ); // // Select Lower Price ... double lowerPrice = GetAppliedPrice( atrLowerAppliedTo, open, high, low, close, bar_index // ); // // Calculate Raw Atrs ... // // Upper ... double atrUpperRawValue = upperPrice + appliedAtrMultiplierValue; atrUpperRawBuffer[bar_index] = atrUpperRawValue; // // Lower ... double atrLowerRawValue = lowerPrice - appliedAtrMultiplierValue; atrLowerRawBuffer[bar_index] = atrLowerRawValue; // bool canSmooth = atrSmoothingMode != X_MA_MODE_NONE; if (canSmooth) { // // Upper ... iMAOnBuffer( ratesTotal, prevCalculated, bar_index, atrLength, atrUpperRawBuffer, atrUpperBuffer, atrSmoothingMode // ); // // Lower ... iMAOnBuffer( ratesTotal, prevCalculated, bar_index, atrLength, atrLowerRawBuffer, atrLowerBuffer, atrSmoothingMode // ); } else { // // Use Raw Values ... atrUpperBuffer[bar_index] = atrUpperRawValue; atrLowerBuffer[bar_index] = atrLowerRawValue; } } /** * Calculate Fibonacci Levels ... * * @param bar_index: Integer, current Bar Index ... */ void CalculateFibonacci( int bar_index // ) { // double fiboUpper = 0; double fiboLower = 0; // fiboUpper = peaksBuffer[bar_index]; fiboLower = valesBuffer[bar_index]; // // Level 1 ... bool canCalculateFiboLevel1 = fiboLevel1 > 0; if (canCalculateFiboLevel1) { // double iFib = GetFibonacciLevel( fiboUpper, fiboLower, fiboLevel1, 1 // ); // fl1Buffer[bar_index] = iFib; } // // Level 2 ... bool canCalculateFiboLevel2 = fiboLevel2 > 0; if (canCalculateFiboLevel2) { // double iFib = GetFibonacciLevel( fiboUpper, fiboLower, fiboLevel2, 1 // ); // fl2Buffer[bar_index] = iFib; } // // Level 3 ... bool canCalculateFiboLevel3 = fiboLevel3 > 0; if (canCalculateFiboLevel3) { // double iFib = GetFibonacciLevel( fiboUpper, fiboLower, fiboLevel3, 1 // ); // fl3Buffer[bar_index] = iFib; } // // Level 4 ... bool canCalculateFiboLevel4 = fiboLevel4 > 0; if (canCalculateFiboLevel4) { // double iFib = GetFibonacciLevel( fiboUpper, fiboLower, fiboLevel4, 1 // ); // fl4Buffer[bar_index] = iFib; } // // Level 5 ... bool canCalculateFiboLevel5 = fiboLevel5 > 0; if (canCalculateFiboLevel5) { // double iFib = GetFibonacciLevel( fiboUpper, fiboLower, fiboLevel5, 1 // ); // fl5Buffer[bar_index] = iFib; } // } //