back-trader-python 1.4.0__py3-none-any.whl

backtrader/indicators/heikinashi.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python
+"""Heikin Ashi Indicator Module - Heikin Ashi candlesticks.
+
+This module provides the Heikin Ashi candlestick indicator which
+creates alternative candlestick charts for trend identification.
+
+Classes:
+    HeikinAshi: Heikin Ashi candlestick lines.
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.ha = bt.indicators.HeikinAshi(self.data)
+
+        def next(self):
+            # Use Heikin Ashi close for trend analysis
+            if self.data.close[0] > self.ha.ha_close[0]:
+                self.buy()
+"""
+
+from . import Indicator
+
+__all__ = ["HeikinAshi"]
+
+
+class HeikinAshi(Indicator):
+    """
+    Heikin Ashi candlesticks in the forms of lines
+
+    Formula:
+        ha_open = (ha_open(-1) + ha_close(-1)) / 2
+        ha_high = max (hi, ha_open, ha_close)
+        ha_low = min (lo, ha_open, ha_close)
+        ha_close = (open + high + low + close) / 4
+
+    See also:
+        https://en.wikipedia.org/wiki/Candlestick_chart#Heikin_Ashi_candlesticks
+        http://stockcharts.com/school/doku.php?id=chart_school:chart_analysis:heikin_ashi
+    """
+
+    lines = (
+        "ha_open",
+        "ha_high",
+        "ha_low",
+        "ha_close",
+    )
+
+    linealias = (
+        (
+            "ha_open",
+            "open",
+        ),
+        (
+            "ha_high",
+            "high",
+        ),
+        (
+            "ha_low",
+            "low",
+        ),
+        (
+            "ha_close",
+            "close",
+        ),
+    )
+
+    plotinfo = {"subplot": False}
+
+    _nextforce = True
+
+    def __init__(self):
+        """Initialize the Heikin Ashi indicator.
+
+        Uses next()/once() methods for calculation to avoid recursive
+        line operation issues.
+        """
+        # CRITICAL FIX: Call super().__init__() FIRST to ensure proper initialization
+        super().__init__()
+        # Use next()/once() methods for calculation to avoid recursive line operation issues
+        # that cause strategy's next() to never be called
+
+    def next(self):
+        """Calculate Heikin Ashi values for the current bar.
+
+        Calculates ha_close, ha_open, ha_high, and ha_low using:
+        - ha_close = (open + high + low + close) / 4
+        - ha_open = (prev_ha_open + prev_ha_close) / 2
+        - ha_high = max(high, ha_open, ha_close)
+        - ha_low = min(low, ha_open, ha_close)
+        """
+        # ha_close = (open + high + low + close) / 4
+        ha_close = (
+            self.data.open[0] + self.data.high[0] + self.data.low[0] + self.data.close[0]
+        ) / 4.0
+        self.lines.ha_close[0] = ha_close
+
+        # ha_open = (ha_open[-1] + ha_close[-1]) / 2
+        # Uses PREVIOUS bar's ha_open and PREVIOUS bar's ha_close
+        if len(self) > 1:
+            ha_open = (self.lines.ha_open[-1] + self.lines.ha_close[-1]) / 2.0
+        else:
+            # First bar: seed with average of open and close
+            ha_open = (self.data.open[0] + self.data.close[0]) / 2.0
+        self.lines.ha_open[0] = ha_open
+
+        # ha_high = max(high, ha_open, ha_close)
+        self.lines.ha_high[0] = max(self.data.high[0], ha_open, ha_close)
+
+        # ha_low = min(low, ha_open, ha_close)
+        self.lines.ha_low[0] = min(self.data.low[0], ha_open, ha_close)
+
+    def prenext(self):
+        """Calculate Heikin Ashi values before minimum period is reached.
+
+        Uses the same calculation as next() to show values from the start.
+        """
+        # Same calculation as next() for prenext period
+        self.next()
+
+    def once(self, start, end):
+        """Batch calculation for runonce mode - matches next() logic exactly"""
+        o_array = self.data.open.array
+        h_array = self.data.high.array
+        l_array = self.data.low.array
+        c_array = self.data.close.array
+
+        ha_open_array = self.lines.ha_open.array
+        ha_high_array = self.lines.ha_high.array
+        ha_low_array = self.lines.ha_low.array
+        ha_close_array = self.lines.ha_close.array
+
+        # Ensure arrays are properly sized
+        for arr in [ha_open_array, ha_high_array, ha_low_array, ha_close_array]:
+            while len(arr) < end:
+                arr.append(float("nan"))
+
+        data_len = min(end, len(o_array), len(h_array), len(l_array), len(c_array))
+        for i in range(start, data_len):
+            # ha_close = (open + high + low + close) / 4
+            ha_close = (o_array[i] + h_array[i] + l_array[i] + c_array[i]) / 4.0
+            ha_close_array[i] = ha_close
+
+            # ha_open = (ha_open[-1] + ha_close[-1]) / 2
+            # Uses PREVIOUS bar's ha_open and PREVIOUS bar's ha_close
+            if i > 0:
+                ha_open = (ha_open_array[i - 1] + ha_close_array[i - 1]) / 2.0
+            else:
+                ha_open = (o_array[i] + c_array[i]) / 2.0
+            ha_open_array[i] = ha_open
+
+            # ha_high and ha_low
+            ha_high_array[i] = max(h_array[i], ha_open, ha_close)
+            ha_low_array[i] = min(l_array[i], ha_open, ha_close)

backtrader/indicators/hma.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python
+"""HMA Indicator Module - Hull Moving Average.
+
+This module provides the HMA (Hull Moving Average) indicator developed
+by Alan Hull to reduce lag while maintaining smoothness.
+
+Classes:
+    HullMovingAverage: HMA indicator (aliases: HMA, HullMA).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.hma = bt.indicators.HMA(self.data.close, period=30)
+
+        def next(self):
+            if self.data.close[0] > self.hma[0]:
+                self.buy()
+"""
+
+import math
+
+from . import MovingAverageBase
+from .wma import WMA
+
+
+class HullMovingAverage(MovingAverageBase):
+    """By Alan Hull
+
+    The Hull Moving Average solves the age-old dilemma of making a moving
+    average more responsive to current price activity whilst maintaining curve
+    smoothness. In fact, the HMA almost eliminates lag altogether and manages to
+    improve smoothing at the same time.
+
+    Formula:
+      - hma = wma(2 * wma(data, period // 2) - wma(data, period), sqrt(period))
+
+    See also:
+      - http://alanhull.com/hull-moving-average
+
+    Note:
+
+      - Please note that the final minimum period is not the period passed with
+        the parameter `period`. A final moving average on moving average is
+        done in which the period is the *square root* of the original.
+
+        In the default case of `30`, the final minimum period before the
+        moving average produces a non-NAN value is ``34``
+    """
+
+    alias = (
+        "HMA",
+        "HullMA",
+    )
+    lines = ("hma",)
+
+    # param 'period' is inherited from MovingAverageBase
+    params = (("_movav", WMA),)
+
+    def __init__(self):
+        """Initialize the Hull Moving Average.
+
+        Creates full-period and half-period WMAs for the HMA calculation.
+        """
+        super().__init__()
+        self.wma_full = self.p._movav(self.data, period=self.p.period)
+        self.wma_half = self.p._movav(self.data, period=self.p.period // 2)
+        self.sqrtperiod = int(pow(self.p.period, 0.5))
+        # minperiod calculation
+        self._minperiod = max(self._minperiod, self.p.period + self.sqrtperiod - 1)
+
+    def _calc_wma(self, values, period):
+        """Calculate WMA for a list of values.
+
+        Args:
+            values: List of values to average.
+            period: Period for WMA calculation.
+
+        Returns:
+            float: Weighted moving average value.
+        """
+        if len(values) < period:
+            return float("nan")
+        coef = 2.0 / (period * (period + 1.0))
+        weights = tuple(float(x) for x in range(1, period + 1))
+        weighted_sum = 0.0
+        for i in range(period):
+            weighted_sum += weights[period - 1 - i] * values[-(i + 1)]
+        return coef * weighted_sum
+
+    def next(self):
+        """Calculate HMA for the current bar.
+
+        Formula: HMA = WMA(2*WMA(n/2) - WMA(n), sqrt(n))
+        """
+        # Get raw values for final WMA calculation
+        sqrtperiod = self.sqrtperiod
+        raw_values = []
+        for i in range(sqrtperiod):
+            wma2_val = 2.0 * self.wma_half[-i]
+            wma_val = self.wma_full[-i]
+            raw_values.append(wma2_val - wma_val)
+        raw_values.reverse()
+
+        self.lines.hma[0] = self._calc_wma(raw_values, sqrtperiod)
+
+    def once(self, start, end):
+        """Calculate HMA in runonce mode."""
+        wma_full_array = self.wma_full.lines[0].array
+        wma_half_array = self.wma_half.lines[0].array
+        larray = self.lines.hma.array
+        period = self.p.period
+        sqrtperiod = self.sqrtperiod
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        minperiod = period + sqrtperiod - 1
+        for i in range(min(minperiod - 1, len(wma_full_array))):
+            if i < len(larray):
+                larray[i] = float("nan")
+
+        # WMA coefficient
+        coef = 2.0 / (sqrtperiod * (sqrtperiod + 1.0))
+        weights = tuple(float(x) for x in range(1, sqrtperiod + 1))
+
+        for i in range(minperiod - 1, min(end, len(wma_full_array), len(wma_half_array))):
+            # Calculate raw = 2 * wma_half - wma_full for last sqrtperiod values
+            weighted_sum = 0.0
+            valid = True
+            for j in range(sqrtperiod):
+                idx = i - j
+                if idx >= 0 and idx < len(wma_full_array) and idx < len(wma_half_array):
+                    wma_full_val = wma_full_array[idx]
+                    wma_half_val = wma_half_array[idx]
+                    if isinstance(wma_full_val, float) and math.isnan(wma_full_val):
+                        valid = False
+                        break
+                    if isinstance(wma_half_val, float) and math.isnan(wma_half_val):
+                        valid = False
+                        break
+                    raw = 2.0 * wma_half_val - wma_full_val
+                    weighted_sum += weights[sqrtperiod - 1 - j] * raw
+                else:
+                    valid = False
+                    break
+
+            if valid and i < len(larray):
+                larray[i] = coef * weighted_sum
+            elif i < len(larray):
+                larray[i] = float("nan")
+
+
+HMA = HullMovingAverage

backtrader/indicators/hurst.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python
+"""Hurst Exponent Module - Hurst exponent indicator.
+
+This module provides the Hurst Exponent indicator for measuring
+long-term memory of time series.
+
+Classes:
+    HurstExponent: Hurst exponent indicator (alias: Hurst).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            # Use at least 2000 samples for stable Hurst values
+            self.hurst = bt.indicators.Hurst(self.data.close, period=2000)
+
+        def next(self):
+            # H > 0.5: trending series, H < 0.5: mean-reverting
+            if len(self.data) >= 2000:
+                if self.hurst[0] > 0.5:
+                    # Trend following strategy
+                    pass
+"""
+
+from numpy import asarray, isnan, log10, polyfit, sqrt, std, subtract
+
+from . import PeriodN
+
+__all__ = ["HurstExponent", "Hurst"]
+
+
+class HurstExponent(PeriodN):
+    """
+     References:
+
+       - https://www.quantopian.com/posts/hurst-exponent
+       - https://www.quantopian.com/posts/some-code-from-ernie-chans-new-book-implemented-in-python
+
+    Interpretation of the results
+
+       1. Geometric random walk (H=0.5)
+       2. Mean-reverting series (H<0.5)
+       3. Trending Series (H>0.5)
+
+     Important notes:
+
+       - The default period is ``40``, but experimentation by users has shown
+         that it would be advisable to have at least 2000 samples (i.e.: a
+         period of at least 2000) to have stable values.
+
+       - The `lag_start` and `lag_end` values will default to be ``2`` and
+         ``self.p.period / 2`` unless the parameters are specified.
+
+         Experimentation by users has also shown that values of around 10 and 500 produce good results
+
+     The original values (40, 2, self.p.period / 2) are kept for backwards
+     compatibility
+
+    """
+
+    frompackages = (("numpy", ("asarray", "log10", "polyfit", "sqrt", "std", "subtract")),)
+
+    alias = ("Hurst",)
+    lines = ("hurst",)
+    params = (
+        ("period", 40),  # 2000 was proposed
+        ("lag_start", None),  # 10 was proposed
+        ("lag_end", None),  # 500 was proposed
+    )
+
+    def _plotlabel(self):
+        plabels = [self.p.period]
+        plabels += [self._lag_start]
+        plabels += [self._lag_end]
+        return plabels
+
+    def __init__(self):
+        """Initialize the Hurst Exponent indicator.
+
+        Prepares lag arrays for calculating the Hurst exponent,
+        which measures the long-term memory of a time series.
+        """
+        super().__init__()
+        # Prepare the lag array
+        self._lag_start = lag_start = self.p.lag_start or 2
+        self._lag_end = lag_end = self.p.lag_end or (self.p.period // 2)
+        self.lags = asarray(range(lag_start, lag_end))
+        self.log10lags = log10(self.lags)
+
+    def next(self):
+        """Calculate Hurst Exponent for the current bar."""
+        # Fetch the data
+        ts = asarray(self.data.get(size=self.p.period))
+
+        # Calculate the array of the variances of the lagged differences
+        tau = [sqrt(std(subtract(ts[lag:], ts[:-lag]))) for lag in self.lags]
+
+        # Use a linear fit to estimate the Hurst Exponent
+        poly = polyfit(self.log10lags, log10(tau), 1)
+
+        # Return the Hurst exponent from the polyfit output
+        self.lines.hurst[0] = poly[0] * 2.0
+
+    def once(self, start, end):
+        """Calculate Hurst Exponent in runonce mode"""
+        dst = self.lines[0].array
+        src = self.data.array
+        period = self.p.period
+        lags = self.lags
+        log10lags = self.log10lags
+
+        # Ensure destination array is large enough
+        while len(dst) < end:
+            dst.append(float("nan"))
+
+        # Calculate Hurst Exponent for each index
+        for i in range(start, end):
+            if i >= period - 1:
+                # Get data slice for this period
+                start_idx = i - period + 1
+                end_idx = i + 1
+                if end_idx <= len(src):
+                    ts = asarray([float(x) for x in src[start_idx:end_idx]])
+
+                    # Calculate the array of the variances of the lagged differences
+                    tau = []
+                    for lag in lags:
+                        if lag < len(ts):
+                            lagged_diff = subtract(ts[lag:], ts[:-lag])
+                            if len(lagged_diff) > 0:
+                                tau_val = sqrt(std(lagged_diff))
+                                if not isnan(tau_val) and tau_val > 0:
+                                    tau.append(tau_val)
+
+                    # Use a linear fit to estimate the Hurst Exponent
+                    if len(tau) > 1 and len(tau) == len(lags):
+                        try:
+                            log10tau = log10(tau)
+                            poly = polyfit(log10lags, log10tau, 1)
+                            hurst = poly[0] * 2.0
+                            dst[i] = float(hurst) if not isnan(hurst) else float("nan")
+                        except (ValueError, TypeError, FloatingPointError):
+                            dst[i] = float("nan")
+                    else:
+                        dst[i] = float("nan")
+                else:
+                    dst[i] = float("nan")
+            else:
+                dst[i] = float("nan")
+
+
+Hurst = HurstExponent