add support for Cycle Provider ...

2025-03-06 23:35:44 +03:30
parent 7e976bc157
commit 6157bbe125
6 changed files with 1488 additions and 1785 deletions
@@ -69,6 +69,7 @@ enum ENUM_X_CYCLE_EVENTS
    VALE_PIVOT_ENDED,
 };

+//
 class XC121SMCCycleHelper : public XCBase
 {
    //
@@ -676,3 +677,403 @@ class XC121SMCCycleHelper : public XCBase

    //
 };
+
+//
+struct X121SMCStrategySignalProviderData
+{
+    //
+    // Props ...
+
+    //
+    // Decision ...
+    XPOIState decisionState;
+    double decisionBullishScore;
+    double decisionBearishScore;
+    X121Conditions decisionXConditions;
+    ENUM_XPOI_EVENTS decisionPoiEvents[];
+    XC121SMCCycleHelper *decisionCycleHelper;
+    ENUM_X_CYCLE_EVENTS decisionCycleEvents[];
+    X121SMCCycleConditions decisionConditions;
+
+    //
+    // Analyse ...
+    XPOIState analyseState;
+    double analyseBullishScore;
+    double analyseBearishScore;
+    X121Conditions analyseXConditions;
+    ENUM_XPOI_EVENTS analysePoiEvents[];
+    XC121SMCCycleHelper *analyseCycleHelper;
+    ENUM_X_CYCLE_EVENTS analyseCycleEvents[];
+    X121SMCCycleConditions analyseConditions;
+
+    //
+    // Consolidation ...
+    XPOIState consolidationState;
+    double consolidationBullishScore;
+    double consolidationBearishScore;
+    X121Conditions consolidationXConditions;
+    ENUM_XPOI_EVENTS consolidationPoiEvents[];
+    XC121SMCCycleHelper *consolidationCycleHelper;
+    ENUM_X_CYCLE_EVENTS consolidationCycleEvents[];
+    X121SMCCycleConditions consolidationConditions;
+
+    //
+    // Vision ...
+    XPOIState visionState;
+    double visionBullishScore;
+    double visionBearishScore;
+    X121Conditions visionXConditions;
+    ENUM_XPOI_EVENTS visionPoiEvents[];
+    XC121SMCCycleHelper *visionCycleHelper;
+    ENUM_X_CYCLE_EVENTS visionCycleEvents[];
+    X121SMCCycleConditions visionConditions;
+
+    //
+    // Constructor ...
+    X121SMCStrategySignalProviderData()
+    {
+        Clean();
+    }
+
+    //
+    // Tools ...
+
+    //
+    // Cleanup ...
+    void Clean()
+    {
+        //
+        // Decision ...
+        decisionState.Clean();
+        decisionBullishScore = 0;
+        decisionBearishScore = 0;
+        Clean(decisionPoiEvents);
+        Clean(decisionCycleEvents);
+        decisionConditions.Clean();
+        decisionXConditions.Clean();
+
+        //
+        // Analyse ...
+        analyseState.Clean();
+        analyseBullishScore = 0;
+        analyseBearishScore = 0;
+        Clean(analysePoiEvents);
+        Clean(analyseCycleEvents);
+        analyseConditions.Clean();
+        analyseXConditions.Clean();
+
+        //
+        // Consolidation ...
+        consolidationState.Clean();
+        consolidationBullishScore = 0;
+        consolidationBearishScore = 0;
+        Clean(consolidationPoiEvents);
+        Clean(consolidationCycleEvents);
+        consolidationConditions.Clean();
+        consolidationXConditions.Clean();
+
+        //
+        // Vision ...
+        visionState.Clean();
+        visionBullishScore = 0;
+        visionBearishScore = 0;
+        Clean(visionPoiEvents);
+        Clean(visionCycleEvents);
+        visionConditions.Clean();
+        visionXConditions.Clean();
+    }
+
+    //
+    void Destroy()
+    {
+        //
+        Clean();
+
+        //
+        ZeroMemory(decisionCycleHelper);
+        ZeroMemory(analyseCycleHelper);
+        ZeroMemory(consolidationCycleHelper);
+        ZeroMemory(visionCycleHelper);
+
+        //
+        ZeroMemory(this);
+    }
+
+    //
+    bool IsValid()
+    {
+        //
+        bool result = false;
+
+        //
+        result =
+            visionCycleHelper != NULL &&
+            analyseCycleHelper != NULL &&
+            decisionCycleHelper != NULL &&
+            consolidationCycleHelper != NULL;
+
+        //
+        return result;
+    }
+
+    //
+    // Initialize ...
+    bool Init(
+        XC121SMCCycleHelper *_decisionCycleHelper,
+        XC121SMCCycleHelper *_analyseCycleHelper,
+        XC121SMCCycleHelper *_consolidationCycleHelper,
+        XC121SMCCycleHelper *_visionCycleHelper //
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        // Validate Cycle Helpers ...
+        result =
+            //
+            _visionCycleHelper != NULL &&
+            _analyseCycleHelper != NULL &&
+            _decisionCycleHelper != NULL &&
+            _consolidationCycleHelper != NULL
+            //
+            ;
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        visionCycleHelper = _visionCycleHelper;
+        analyseCycleHelper = _analyseCycleHelper;
+        decisionCycleHelper = _decisionCycleHelper;
+        consolidationCycleHelper = _consolidationCycleHelper;
+
+        //
+        result = IsValid();
+
+        //
+        return result;
+    }
+
+    //
+    // Prepare all ...
+    bool Prepare(
+        int barIndex = 0,
+        int loopback = 10 //
+    )
+    {
+        //
+        bool result = false;
+
+        //
+        if (barIndex < 0)
+        {
+            barIndex = 0;
+        }
+
+        //
+        if (loopback < 7)
+        {
+            loopback = 7;
+        }
+
+        //
+        result = IsValid();
+        if (!result)
+        {
+            return result;
+        }
+
+        //
+        // Decision ...
+        result = decisionCycleHelper.GetConditions(
+            decisionCycleEvents,
+            decisionPoiEvents,
+            decisionConditions,
+            barIndex,
+            loopback //
+        );
+        if (!result)
+        {
+            //
+            Clean(decisionPoiEvents);
+            Clean(decisionCycleEvents);
+
+            //
+            decisionConditions.Clean();
+
+            //
+            return result;
+        }
+
+        //
+        // Analyse ...
+        result = analyseCycleHelper.GetConditions(
+            analyseCycleEvents,
+            analysePoiEvents,
+            analyseConditions,
+            barIndex,
+            loopback //
+        );
+        if (!result)
+        {
+            //
+            Clean(analysePoiEvents);
+            Clean(decisionPoiEvents);
+
+            //
+            Clean(analyseCycleEvents);
+            Clean(decisionCycleEvents);
+
+            //
+            analyseConditions.Clean();
+            decisionConditions.Clean();
+
+            //
+            return result;
+        }
+
+        //
+        // Consolidation ...
+        result = consolidationCycleHelper.GetConditions(
+            consolidationCycleEvents,
+            consolidationPoiEvents,
+            consolidationConditions,
+            barIndex,
+            loopback //
+        );
+        if (!result)
+        {
+            //
+            Clean(analysePoiEvents);
+            Clean(decisionPoiEvents);
+            Clean(consolidationPoiEvents);
+
+            //
+            Clean(analyseCycleEvents);
+            Clean(decisionCycleEvents);
+            Clean(consolidationCycleEvents);
+
+            //
+            analyseConditions.Clean();
+            decisionConditions.Clean();
+            consolidationConditions.Clean();
+
+            //
+            return result;
+        }
+
+        //
+        // Vision ...
+        result = visionCycleHelper.GetConditions(
+            visionCycleEvents,
+            visionPoiEvents,
+            visionConditions,
+            barIndex,
+            loopback //
+        );
+        if (!result)
+        {
+            //
+            Clean(visionPoiEvents);
+            Clean(analysePoiEvents);
+            Clean(decisionPoiEvents);
+            Clean(consolidationPoiEvents);
+
+            //
+            Clean(visionCycleEvents);
+            Clean(analyseCycleEvents);
+            Clean(decisionCycleEvents);
+            Clean(consolidationCycleEvents);
+
+            //
+            visionConditions.Clean();
+            analyseConditions.Clean();
+            decisionConditions.Clean();
+            consolidationConditions.Clean();
+
+            //
+            return result;
+        }
+
+        //
+        // Cycles POI States ...
+        decisionState = decisionConditions.state;
+        analyseState = analyseConditions.state;
+        consolidationState = consolidationConditions.state;
+        visionState = visionConditions.state;
+
+        //
+        // Cycle X121Conditions ...
+        decisionXConditions = decisionConditions.x121Conditions;
+        analyseXConditions = analyseConditions.x121Conditions;
+        consolidationXConditions = consolidationConditions.x121Conditions;
+        visionXConditions = visionConditions.x121Conditions;
+
+        //
+        // Decision ...
+        decisionXConditions.GenerateScore(
+            decisionBullishScore,
+            decisionBearishScore //
+        );
+
+        //
+        // Analyse ...
+        analyseXConditions.GenerateScore(
+            analyseBullishScore,
+            analyseBearishScore //
+        );
+
+        //
+        // Consolidation ...
+        consolidationXConditions.GenerateScore(
+            consolidationBullishScore,
+            consolidationBearishScore //
+        );
+
+        //
+        // Vision ...
+        visionXConditions.GenerateScore(
+            visionBullishScore,
+            visionBearishScore //
+        );
+
+        //
+        return result;
+    }
+
+    //
+    void MaxRequiredPOIs(int value)
+    {
+        //
+        if (!IsValid())
+        {
+            return;
+        }
+
+        //
+        visionCycleHelper.mPOIDetector.MaxRequiredPOIs(value);
+        analyseCycleHelper.mPOIDetector.MaxRequiredPOIs(value);
+        decisionCycleHelper.mPOIDetector.MaxRequiredPOIs(value);
+        consolidationCycleHelper.mPOIDetector.MaxRequiredPOIs(value);
+    }
+
+    //
+    void MaxAllowedLoopbackForInit(int value)
+    {
+        //
+        if (!IsValid())
+        {
+            return;
+        }
+
+        //
+        visionCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(value);
+        analyseCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(value);
+        decisionCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(value);
+        consolidationCycleHelper.mPOIDetector.MaxAllowedLoopbackForInit(value);
+    }
+
+    //
+};