#154 Refactor chaos and phase adjustment logic, fix tests.

Author: Tim55667757

tests/test_TradeRoutines.py

@@ -1220,7 +1220,7 @@ def test_EstimateTargetReachabilityCheckType(self):
 
         # Test function call:
         pIntegral, fIntegral = TradeRoutines.EstimateTargetReachability(
-            seriesLowTF, seriesHighTF, currentPrice, targetPrice, 12, 4, ddof=2
+            seriesLowTF, seriesHighTF, currentPrice, targetPrice, 12, 4, ddof=2, chaosTrust=1.0, phaseTrust=1.0
         )
 
         # Check return types:
@@ -1230,25 +1230,21 @@ def test_EstimateTargetReachabilityCheckType(self):
 
     def test_EstimateTargetReachabilityPositive(self):
         testCases = [
-            (self.GenerateSeries(150), self.GenerateSeries(40), 12, 3),
-            (self.GenerateSeries(300), self.GenerateSeries(60), 20, 5),
-            (self.GenerateSeries(1000), self.GenerateSeries(100), 15, 4),
-            (
-                self.GenerateSeries(250), self.GenerateSeries(80), 10, 3,
-                {"useChaos": True, "chaosModel": "hurst", "chaosTail": 100, "usePhase": True, "phaseDirection": "Buy"}
-            ),
+            (self.GenerateSeries(150), self.GenerateSeries(40), 12, 3, 1.0, 1.0),
+            (self.GenerateSeries(300), self.GenerateSeries(60), 20, 5, 1.0, 0.9),
+            (self.GenerateSeries(1000), self.GenerateSeries(100), 15, 4, 0.9, 1.0),
+            (self.GenerateSeries(250), self.GenerateSeries(80), 10, 3, 0.9, 0.8),
         ]
 
         for test in testCases:
-            seriesLowTF, seriesHighTF, horizonLowTF, horizonHighTF = test[:4]
-            kwargs = test[4] if len(test) > 4 else {}
+            seriesLowTF, seriesHighTF, horizonLowTF, horizonHighTF, chaosTrust, phaseTrust = test
 
             currentPrice = seriesLowTF.iloc[-1]
             targetPrice = currentPrice * 1.07
 
             pIntegral, fIntegral = TradeRoutines.EstimateTargetReachability(
                 seriesLowTF, seriesHighTF, currentPrice, targetPrice,
-                horizonLowTF, horizonHighTF, ddof=2, **kwargs
+                horizonLowTF, horizonHighTF, ddof=2, chaosTrust=chaosTrust, phaseTrust=phaseTrust
             )
 
             # Probability must be within [0, 1]:
@@ -1271,11 +1267,11 @@ def test_EstimateTargetReachabilityNegative(self):
             (emptySeries, emptySeries, 100, 110, 10, 5),  # Empty Pandas series
 
             # Edge cases with chaos/phase flags (should still return fallback):
-            ([], [], 100, 110, 10, 5, {"useChaos": True, "chaosTail": 0}),
-            ([100], [100], 100, 110, 10, 5, {"usePhase": True, "phaseDirection": "Sell"}),
-            (validSeries, validSeries, 100, 110, 10, 0, {"useChaos": True, "chaosTail": -100, "usePhase": True}),
-            (validSeries, validSeries, 100, 110, 10, 0, {"useChaos": True, "chaosTail": None, "usePhase": True}),
-            (validSeries, validSeries, 100, 110, 10, 0, {"useChaos": True, "chaosTail": 101, "usePhase": True}),
+            ([], [], 100, 110, 10, 5, {"chaosTrust": 0, "phaseTrust": 0}),
+            ([100], [100], 100, 110, 10, 5, {"chaosTrust": -1, "phaseTrust": -1}),
+            (validSeries, validSeries, 100, 110, 10, 0, {"chaosTrust": 0, "phaseTrust": -1}),
+            (validSeries, validSeries, 100, 110, 10, 0, {"chaosTrust": -1, "phaseTrust": 0}),
+            (validSeries, validSeries, 100, 110, 10, 0, {"chaosTrust": 100, "phaseTrust": 100}),
         ]
 
         for test in testCases:
@@ -1305,13 +1301,7 @@ def test_EstimateTargetReachabilityPerformance(self):
             targetPrice = currentPrice * 1.05
 
             # Enable chaos and phase modifiers with tail slicing:
-            kwargs = {
-                "useChaos": True,
-                "chaosModel": "hurst",
-                "chaosTail": 1001,
-                "usePhase": True,
-                "phaseDirection": "Buy",
-            }
+            kwargs = {"chaosTrust": 0.8, "phaseTrust": 0.7}
 
             startTime = time.perf_counter()
 

tksbrokerapi/TradeRoutines.py

@@ -1699,11 +1699,8 @@ def EstimateTargetReachability(
     horizonHighTF: int,
     ddof: int = 2,
     cleanWithHampel: bool = False,
-    useChaos: bool = False,
-    chaosModel: str = "hurst",
-    chaosTail: Optional[int] = None,
-    usePhase: bool = False,
-    phaseDirection: Optional[str] = None,
+    chaosTrust: float = 1.0,
+    phaseTrust: float = 1.0,
     **kwargs
 ) -> tuple[float, str]:
     """
@@ -1729,14 +1726,8 @@ def EstimateTargetReachability(
     :param cleanWithHampel: If `True`, applies outlier cleaning to both input series before computing log returns
                             using `HampelCleaner()` (`False` by default). Recommended for real market data where spikes,
                             anomalies, or gaps may distort volatility and probability estimates.
-    :param useChaos: If `True`, modifies the final probability based on chaos confidence (Hurst, DFA, etc.).
-    :param chaosModel: Chaos model to use
-        - `hurst`: fast estimation of Hurst exponent using the rescaled range (R/S) method, `FastHurst()`;
-        - `sampen`: fast Sample Entropy for chaos estimation, see `FastSampEn()`;
-        - `dfa`: fast Detrended Fluctuation Analysis (DFA) estimator, see `FastDfa()`.
-    :param chaosTail: Optional tail length of the series `seriesLowTF` and `seriesHighTF` used for chaos estimation. If `None`, use the full series.
-    :param usePhase: If `True`, modifies the final probability based on Bollinger-band phase, see `FastBBands()`.
-    :param phaseDirection: Trade direction: `Buy` or `Sell` (required for phase confidence).
+    :param chaosTrust: Trust coefficient based on chaos metric ∈ [0.0, 1.0]. Default is `1.0` (no modification), see also `ChaosConfidence()`.
+    :param phaseTrust: Trust coefficient based on Bollinger-band phase ∈ [0.0, 1.0]. Default is` 1.0` (no modification), see also `PhaseConfidence()`.
     :param kwargs: Optional keyword arguments are forwarded to `HampelCleaner()` if `cleanWithHampel` is `True`.
                    Supported options (with default values):
         - `window` (5): Sliding window size for `HampelCleaner()`.
@@ -1815,31 +1806,15 @@ def EstimateTargetReachability(
         # --- Formula (12): Final integrated probability:
         pIntegral = alpha * pBayes + (1 - alpha) * pAverage
 
-        # --- Chaos trust modifier (if enabled):
-        chaosTrust = 1.0
-        if useChaos:
-            tailL = seriesLowTF.values[-chaosTail:] if chaosTail else seriesLowTF.values
-            tailH = seriesHighTF.values[-chaosTail:] if chaosTail else seriesHighTF.values
-
-            chaosL = ChaosMeasure(tailL, model=chaosModel)
-            confL = ChaosConfidence(chaosL, chaosModel)
-
-            chaosH = ChaosMeasure(tailH, model=chaosModel)
-            confH = ChaosConfidence(chaosH, chaosModel)
-
-            chaosTrust = alpha * confL + (1 - alpha) * confH
-
-        # --- Phase trust modifier (if enabled):
-        phaseTrust = 1.0
-        if usePhase and phaseDirection:
-            bbLower = min(seriesLowTF.values[-1], seriesHighTF.values[-1])
-            bbUpper = max(seriesLowTF.values[-1], seriesHighTF.values[-1])
-            phase = PhaseLocation(currentPrice, bbLower, bbUpper)
+        # --- Apply combined trust modifiers:
+        if chaosTrust == 1.0 and phaseTrust == 1.0:
+            pFinal = pIntegral
 
-            phaseTrust = PhaseConfidence(phase, phaseDirection)
+        elif not (0.0 <= chaosTrust <= 1.0 and 0.0 <= phaseTrust <= 1.0):
+            pFinal = pIntegral  # Skip adjustment if trust coefficients are invalid.
 
-        # --- Apply combined trust modifiers:
-        pFinal = pIntegral if chaosTrust == phaseTrust == 1.0 else AdjustProbabilityByChaosAndPhaseTrust(pIntegral, chaosTrust, phaseTrust)
+        else:
+            pFinal = AdjustProbabilityByChaosAndPhaseTrust(pIntegral, chaosTrust, phaseTrust)
 
         # --- Formula (15): Fuzzy classification of the final probability:
         fFinal = FUZZY_SCALE.Fuzzy(pFinal)["name"]