///////////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 Cycle Trend Detector Indicator // --------------------------------------------------------- // Name: XCTD // Description: trend detecting based on cycles ... // // // 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 XCTD Indicator" #property strict // // START Constants ... // #define ShortName "XCTD" // // Including Models Library ... #include "..\Libraries\x-saherelm.models.lib.mq5" // // END Constants ... // // // START Inputs ... // // input int fastLength = 9; // Fast Length input int slowLength = 18; // Slow Length // input ENUM_MA_METHOD method = MODE_EMA; // Calculation Method input ENUM_APPLIED_PRICE appliedTo = PRICE_CLOSE; // Applied To // // END Inputs ... // // // Includes Logging Library ... #include "../Libraries/x-saherelm.log.lib.mq5"; // // Includes Common Library ... #include "../Libraries/x-saherelm.common.lib.mq5"; // // START Buffers ... // #property indicator_chart_window // #property indicator_buffers 6 #property indicator_plots 2 // #define fastBufferIndex 0 #define slowBufferIndex 1 #define maBufferIndex 2 #define stateBufferIndex 3 #define fastPowerBufferIndex 4 #define slowPowerBufferIndex 5 // double fastBuffer[]; double slowBuffer[]; // // INDICATOR CALCULATIONS BUFFERS ... // // Just Holds a simple Moving Average for Chart Draw Long Cycles ... double maBuffer[]; // // holds Fast based On Slow States ... double stateBuffer[]; // // Holds Fast Summerize Value ... // if Fast[0] > Fast[1] => FastPow += Fast[1] // else FastPow -= Fast[1] double fastPowerBuffer[]; // // Holds Slow Summerize Value ... // if Slow[0] > Slow[1] => SlowPow += Slow[1] // else SlowPow -= Slow[1] double slowPowerBuffer[]; #property indicator_label1 "XCTD Fast" #property indicator_type1 DRAW_LINE #property indicator_color1 clrAqua #property indicator_style1 STYLE_DOT #property indicator_width1 1 #property indicator_label2 "XCTD Slow" #property indicator_type2 DRAW_LINE #property indicator_color2 clrFuchsia #property indicator_style2 STYLE_DOT #property indicator_width2 1 // // END Buffers ... // // // START Global Definitions: Variables, Properties and etc ... // // // XCTD States ... enum ENUM_X_XCTD_STATES { X_XCTD_FAST_CROSSED_OVER_SLOW = 2, X_XCTD_FAST_OVER_SLOW = 1, X_XCTD_NEUTURAL = 0, X_XCTD_FAST_UNDER_SLOW = -1, X_XCTD_FAST_CROSSED_UNDER_SLOW = -2, }; // // XCTD Buffer Lines ... enum ENUM_X_XCTD_BUFFER_LINES { X_XCTD_FAST_LINE = 0, X_XCTD_SLOW_LINE = 1, X_XCTD_STATE_LINE = 2, }; // ENUM_TIMEFRAMES cyclePeriod; int maHandler = INVALID_HANDLE; int fastHandler = INVALID_HANDLE; int slowHandler = INVALID_HANDLE; // // END Global Definitions: Variables, Properties and etc ... // // // START Event Handlers ... // // // Initialization ... int OnInit() { // // Validate Inputs ... if (!ValidateInputs()) { return INIT_PARAMETERS_INCORRECT; } // logTag = ShortName; // // Define Index Buffers ... DefineBuffers(); // // Set Indicator ShortName ... SetIndicatorName(); // // Resetting Last Error ... ResetLastError(); // // Initialized Requirements ... cyclePeriod = GetFarestTimeFrame(); // // Ma Buffer ... maHandler = iMA( _Symbol, _Period, 14, 0, MODE_SMA, PRICE_CLOSE); if (maHandler == INVALID_HANDLE) { // LogMessage("Error in Ma Indicator initialization: " + (string)GetLastError()); // return INIT_FAILED; } // // fatst Handler ... fastHandler = iMA( _Symbol, cyclePeriod, fastLength, 0, method, appliedTo); if (fastHandler == INVALID_HANDLE) { // LogMessage("Error in Fast Indicator initialization: " + (string)GetLastError()); // return INIT_FAILED; } // // slow Handler ... slowHandler = iMA( _Symbol, cyclePeriod, slowLength, 0, method, appliedTo); if (slowHandler == INVALID_HANDLE) { // LogMessage("Error in Slow Indicator initialization: " + (string)GetLastError()); // return INIT_FAILED; } // Comment(ShortName + " Cycle Period: " + EnumToString(cyclePeriod)); // // Init Succeed ... return INIT_SUCCEEDED; } // // DeInitialization ... 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 // // Here we can handle De Initialization Reasons ... // // ReDraw Chart ... ChartRedraw(); // Comment(""); } // // Calculations ... // // Calculating what we want ... int OnCalculate( // // total Candles on chart ... const int rates_total, // // total calculated Candles on charts ... const int prev_calculated, // // history of Candles Open Time ... const datetime &time[], // // history of Candles Open Price ... const double &open[], // // history of Candles High Price ... const double &high[], // // history of Candles Low Price ... const double &low[], // // history of Candles Close Price ... const double &close[], // // history of Tick Volumes on Candle ... const long &tick_volume[], // // history of Trade Volumes ... const long &volume[], // // history of Candles Spread Price ... 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); // // this counts Available Bars ... int limit; // // 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 ... int maxLength = MathMax(fastLength, slowLength); maxLength = MathMax(maxLength, 14); // // Get Retrieved Values from indicators ... int maCalculatedBars = BarsCalculated(maHandler); int fastCalculatedBars = BarsCalculated(fastHandler); int slowCalculatedBars = BarsCalculated(slowHandler); // // Check Calculated Bars ... if ( maCalculatedBars < maxLength || fastCalculatedBars < maxLength || slowCalculatedBars < maxLength) { return prev_calculated; } // limit = prev_calculated < maxLength ? rates_total - (maxLength + 1) : rates_total - prev_calculated; // // Copy Buffers from indicators ... int maCopiedItems = CopyBuffer(maHandler, 0, 0, limit + 1, maBuffer); int fastCopiedItems = CopyBuffer(fastHandler, 0, 0, limit + 1, fastBuffer); int slowCopiedItems = CopyBuffer(slowHandler, 0, 0, limit + 1, slowBuffer); // // Check Copied Items Number ... if ( maCopiedItems <= 0 || fastCopiedItems <= 0 || slowCopiedItems <= 0) { return prev_calculated; } // // Main Loop ... for (int i = limit; i >= 0 && !IsStopped(); i--) { // CalculateBuffers(i); } // return rates_total; } // // END Event Handlers ... // // // START Functions ... // // // Validate Input Args for Initialization ... bool ValidateInputs() { // bool result = false; // // Validate Args ... if (fastLength >= 4 && slowLength > fastLength) { result = true; } // return result; } // // Define Indexes and Styles ... void DefineBuffers() { // string fastBufferLabel = ShortName + " Fast (" + (string)fastLength + ")"; string slowBufferLabel = ShortName + " Slow (" + (string)slowLength + ")"; // // MA Buffer ... ArraySetAsSeries(maBuffer, true); SetIndexBuffer(maBufferIndex, maBuffer, INDICATOR_CALCULATIONS); // // Fast Buffer ... ArraySetAsSeries(fastBuffer, true); SetIndexBuffer(fastBufferIndex, fastBuffer, INDICATOR_DATA); PlotIndexSetInteger(fastBufferIndex, PLOT_DRAW_BEGIN, fastLength); PlotIndexSetString(fastBufferIndex, PLOT_LABEL, fastBufferLabel); // // Slow Buffer ... ArraySetAsSeries(slowBuffer, true); SetIndexBuffer(slowBufferIndex, slowBuffer, INDICATOR_DATA); PlotIndexSetInteger(slowBufferIndex, PLOT_DRAW_BEGIN, slowLength); PlotIndexSetString(slowBufferIndex, PLOT_LABEL, slowBufferLabel); // // State Buffer ... ArraySetAsSeries(stateBuffer, true); SetIndexBuffer(stateBufferIndex, stateBuffer, INDICATOR_CALCULATIONS); // // Fast Power Buffer ... ArraySetAsSeries(fastPowerBuffer, true); SetIndexBuffer(fastPowerBufferIndex, fastPowerBuffer, INDICATOR_CALCULATIONS); // // Slow Power Buffer ... ArraySetAsSeries(slowPowerBuffer, true); SetIndexBuffer(slowPowerBufferIndex, slowPowerBuffer, INDICATOR_CALCULATIONS); } // // Set Indicator Short Name and also we can define Buffers Labels ... void SetIndicatorName() { // string indicatorShortName = ""; StringConcatenate(indicatorShortName, ShortName, ""); // IndicatorSetString(INDICATOR_SHORTNAME, indicatorShortName); } // // Calculate Buffers ... void CalculateBuffers(int bar_index) { // // here we must calculate required Buffers ... // Ma, Fast and Slow buffers filled using CopyBuffer ... // StateBuffer/FastPowerBuffer and SlowPowerBuffer needs to Calculate ... // // Retrieve Different State ... bool isFastCrossedOverSlow = IsCrossOver(fastBuffer, slowBuffer, bar_index); bool isFastOverSlow = IsOver(fastBuffer, slowBuffer, bar_index); bool isFastCrossedUnderSlow = IsCrossUnder(fastBuffer, slowBuffer, bar_index); bool isFastUnderSlow = IsUnder(fastBuffer, slowBuffer, bar_index); // // Calculate State Buffer ... double stateValue = X_XCTD_NEUTURAL; if (isFastCrossedOverSlow) { stateValue = X_XCTD_FAST_CROSSED_OVER_SLOW; } else if (isFastCrossedUnderSlow) { stateValue = X_XCTD_FAST_CROSSED_UNDER_SLOW; } else if (isFastOverSlow) { stateValue = X_XCTD_FAST_OVER_SLOW; } else if (isFastUnderSlow) { stateValue = X_XCTD_FAST_UNDER_SLOW; } // stateBuffer[bar_index] = stateValue; // // Calculate FastPower Buffer ... if (ArraySize(fastPowerBuffer) <= fastLength) { fastPowerBuffer[bar_index] = 0; // fastBuffer[bar_index]; } else { // double fastDiff = fastBuffer[bar_index] - fastBuffer[bar_index + 1]; double fastPowerValue = fastPowerBuffer[bar_index + 1] + fastDiff; // // // if (fastBuffer[bar_index] > fastBuffer[bar_index + 1]) // { // fastPowerValue += fastBuffer[bar_index]; // } // else // { // fastPowerValue -= fastBuffer[bar_index]; // } // fastPowerBuffer[bar_index] = fastPowerValue; } // // Calculate SlowPower Buffer ... if (ArraySize(slowPowerBuffer) <= slowLength) { slowPowerBuffer[bar_index] = 0; // slowBuffer[bar_index]; } else { // double slowDiff = slowBuffer[bar_index] - slowBuffer[bar_index + 1]; double slowPowerValue = slowPowerBuffer[bar_index + 1] + slowDiff; // // if (slowBuffer[bar_index] > slowBuffer[bar_index + 1]) // { // slowPowerValue += slowBuffer[bar_index]; // } // else // { // slowPowerValue -= slowBuffer[bar_index]; // } // slowPowerBuffer[bar_index] = slowPowerValue; } } // // END Functions ... //