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

backtrader/indicators/momentum.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python
+"""Momentum Indicator Module - Momentum and Rate of Change.
+
+This module provides momentum-based indicators for measuring the rate
+of price change over a given period.
+
+Classes:
+    Momentum: Measures price change (difference).
+    MomentumOscillator: Momentum as ratio (alias: MomentumOsc).
+    RateOfChange: Rate of change indicator (alias: ROC).
+    RateOfChange100: ROC with base 100 (alias: ROC100).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.mom = bt.indicators.Momentum(self.data.close, period=12)
+            self.roc = bt.indicators.ROC(self.data.close, period=10)
+            self.roc100 = bt.indicators.ROC100(self.data.close, period=12)
+
+        def next(self):
+            # Momentum-based strategy
+            if self.mom.momentum[0] > 0:
+                self.buy()
+            elif self.mom.momentum[0] < 0:
+                self.sell()
+"""
+
+from . import Indicator
+
+
+class Momentum(Indicator):
+    """
+    Measures the change in price by calculating the difference between the
+    current price and the price from a given period ago
+
+
+    Formula:
+      - momentum = data - data_period
+
+    See:
+      - http://en.wikipedia.org/wiki/Momentum_(technical_analysis)
+    """
+
+    lines = ("momentum",)
+    params = (("period", 12),)
+    plotinfo = {"plothlines": [0.0]}
+
+    def __init__(self):
+        """Initialize the Momentum indicator.
+
+        Sets minimum period to period + 1 for difference calculation.
+        """
+        super().__init__()
+        self.addminperiod(self.p.period + 1)
+
+    def next(self):
+        """Calculate momentum for the current bar.
+
+        Momentum = current_price - price_period_ago
+        """
+        self.lines.momentum[0] = self.data[0] - self.data[-self.p.period]
+
+    def once(self, start, end):
+        """Calculate momentum in runonce mode.
+
+        Computes price difference across all bars.
+        """
+        darray = self.data.array
+        larray = self.lines.momentum.array
+        period = self.p.period
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        for i in range(period, min(end, len(darray))):
+            larray[i] = darray[i] - darray[i - period]
+
+
+class MomentumOscillator(Indicator):
+    """
+    Measures the ratio of change in prices over a period
+
+    Formula:
+      - mosc = 100 * (data / data_period)
+
+    See:
+      - http://ta.mql4.com/indicators/oscillators/momentum
+    """
+
+    alias = ("MomentumOsc",)
+
+    # Named output lines
+    lines = ("momosc",)
+
+    # Accepted parameters (and defaults)
+    params = (("period", 12), ("band", 100.0))
+
+    def _plotlabel(self):
+        plabels = [self.p.period]
+        return plabels
+
+    def _plotinit(self):
+        self.plotinfo.plothlines = [self.p.band]
+
+    def __init__(self):
+        """Initialize the Momentum Oscillator indicator.
+
+        Sets minimum period to period + 1 for ratio calculation.
+        """
+        super().__init__()
+        self.addminperiod(self.p.period + 1)
+
+    def next(self):
+        """Calculate momentum oscillator for the current bar.
+
+        Oscillator = 100 * (current_price / price_period_ago)
+        Returns 0.0 if previous value is 0 to avoid division by zero.
+        """
+        prev_val = self.data[-self.p.period]
+        if prev_val != 0:
+            self.lines.momosc[0] = 100.0 * (self.data[0] / prev_val)
+        else:
+            self.lines.momosc[0] = 0.0
+
+    def once(self, start, end):
+        """Calculate momentum oscillator in runonce mode.
+
+        Computes 100 * ratio across all bars.
+        """
+        darray = self.data.array
+        larray = self.lines.momosc.array
+        period = self.p.period
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        for i in range(period, min(end, len(darray))):
+            prev_val = darray[i - period]
+            if prev_val != 0:
+                larray[i] = 100.0 * (darray[i] / prev_val)
+            else:
+                larray[i] = 0.0
+
+
+class RateOfChange(Indicator):
+    """
+    Measures the ratio of change in prices over a period
+
+    Formula:
+      - roc = (data - data_period) / data_period
+
+    See:
+      - http://en.wikipedia.org/wiki/Momentum_(technical_analysis)
+    """
+
+    alias = ("ROC",)
+
+    # Named output lines
+    lines = ("roc",)
+
+    # Accepted parameters (and defaults)
+    params = (("period", 12),)
+
+    def __init__(self):
+        """Initialize the Rate of Change indicator.
+
+        Sets minimum period to period + 1 for ratio calculation.
+        """
+        super().__init__()
+        self.addminperiod(self.p.period + 1)
+
+    def next(self):
+        """Calculate ROC for the current bar.
+
+        ROC = (current_price - price_period_ago) / price_period_ago
+        Returns 0.0 if previous value is 0 to avoid division by zero.
+        """
+        prev_val = self.data[-self.p.period]
+        if prev_val != 0:
+            self.lines.roc[0] = (self.data[0] - prev_val) / prev_val
+        else:
+            self.lines.roc[0] = 0.0
+
+    def once(self, start, end):
+        """Calculate ROC in runonce mode.
+
+        Computes rate of change ratio across all bars.
+        """
+        darray = self.data.array
+        larray = self.lines.roc.array
+        period = self.p.period
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        for i in range(period, min(end, len(darray))):
+            prev_val = darray[i - period]
+            if prev_val != 0:
+                larray[i] = (darray[i] - prev_val) / prev_val
+            else:
+                larray[i] = 0.0
+
+
+class RateOfChange100(Indicator):
+    """
+    Measures the ratio of change in prices over a period with base 100
+
+    This is, for example, how ROC is defined in stockcharts
+
+    Formula:
+      - roc = 100 * (data - data_period) / data_period
+
+    See:
+      - http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:rate_of_change_roc_and_momentum
+
+    """
+
+    alias = ("ROC100",)
+
+    # Named output lines
+    lines = ("roc100",)
+
+    # Accepted parameters (and defaults)
+    params = (("period", 12),)
+
+    def __init__(self):
+        """Initialize the ROC100 indicator.
+
+        Sets minimum period to period + 1 for ratio calculation.
+        """
+        super().__init__()
+        self.addminperiod(self.p.period + 1)
+
+    def next(self):
+        """Calculate ROC100 for the current bar.
+
+        ROC100 = 100 * (current_price - price_period_ago) / price_period_ago
+        Returns 0.0 if previous value is 0 to avoid division by zero.
+        """
+        prev_val = self.data[-self.p.period]
+        if prev_val != 0:
+            self.lines.roc100[0] = 100.0 * (self.data[0] - prev_val) / prev_val
+        else:
+            self.lines.roc100[0] = 0.0
+
+    def once(self, start, end):
+        """Calculate ROC100 in runonce mode.
+
+        Computes rate of change with base 100 across all bars.
+        """
+        darray = self.data.array
+        larray = self.lines.roc100.array
+        period = self.p.period
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        for i in range(period, min(end, len(darray))):
+            prev_val = darray[i - period]
+            if prev_val != 0:
+                larray[i] = 100.0 * (darray[i] - prev_val) / prev_val
+            else:
+                larray[i] = 0.0
+
+
+ROC = RateOfChange
+ROC100 = RateOfChange100

backtrader/indicators/moneyflow.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python
+"""Money flow indicators migrated from functional strategy tests."""
+
+from . import Indicator
+from .atr import ATR
+
+__all__ = [
+    "DeltaMFI",
+    "MFI",
+    "MFIHistogramIndicator",
+    "MFISlowdown",
+    "MoneyFlowIndex",
+]
+
+
+class MoneyFlowIndex(Indicator):
+    """Money Flow Index using a current-inclusive lookback window."""
+
+    lines = ("mfi",)
+    params = (("period", 14),)
+
+    def __init__(self):
+        """Register the rolling window size needed for the MFI calculation."""
+        self.addminperiod(self.p.period + 1)
+
+    def next(self):
+        """Compute the Money Flow Index for the current bar.
+
+        Walks the most recent ``period`` bars (current inclusive), sums
+        the positive raw money flow (typical price rising) and the
+        negative raw money flow (typical price falling) where the raw
+        flow is ``typical_price * volume``. The MFI is then written as
+        ``100 - 100 / (1 + positive/negative)``; when no negative flow
+        is observed, the indicator is saturated at ``100.0``.
+        """
+        positive_flow = 0.0
+        negative_flow = 0.0
+        for i in range(self.p.period):
+            curr_tp = (
+                float(self.data.high[-i]) + float(self.data.low[-i]) + float(self.data.close[-i])
+            ) / 3.0
+            prev_tp = (
+                float(self.data.high[-i - 1])
+                + float(self.data.low[-i - 1])
+                + float(self.data.close[-i - 1])
+            ) / 3.0
+            raw_flow = curr_tp * float(self.data.volume[-i])
+            if curr_tp > prev_tp:
+                positive_flow += raw_flow
+            elif curr_tp < prev_tp:
+                negative_flow += raw_flow
+
+        if negative_flow == 0.0:
+            self.lines.mfi[0] = 100.0
+        else:
+            money_ratio = positive_flow / negative_flow
+            self.lines.mfi[0] = 100.0 - (100.0 / (1.0 + money_ratio))
+
+
+class MFI(Indicator):
+    """Money Flow Index variant using the previous completed window.
+
+    Some functional strategies historically calculated MFI over
+    ``range(-period, 0)`` instead of including bar 0. This class preserves
+    that behavior and is intentionally not an alias of ``MoneyFlowIndex``.
+    """
+
+    lines = ("mfi",)
+    params = (("period", 14),)
+
+    def __init__(self):
+        """Register the rolling window size needed for the MFI calculation."""
+        self.addminperiod(self.p.period + 1)
+
+    def next(self):
+        """Compute MFI over the previous ``period`` bars (not the current bar).
+
+        Unlike :class:`MoneyFlowIndex`, the loop indexes
+        ``range(-period, 0)`` so the current bar is excluded from the
+        window. The positive/negative flow split and saturation rule
+        are otherwise identical. This preserves the historical
+        functional-strategy behavior.
+        """
+        period = self.p.period
+        pos_flow = 0.0
+        neg_flow = 0.0
+        for i in range(-period, 0):
+            tp_cur = (
+                float(self.data.high[i]) + float(self.data.low[i]) + float(self.data.close[i])
+            ) / 3.0
+            tp_prev = (
+                float(self.data.high[i - 1])
+                + float(self.data.low[i - 1])
+                + float(self.data.close[i - 1])
+            ) / 3.0
+            mf = tp_cur * float(self.data.volume[i])
+            if tp_cur > tp_prev:
+                pos_flow += mf
+            elif tp_cur < tp_prev:
+                neg_flow += mf
+
+        if neg_flow == 0:
+            self.lines.mfi[0] = 100.0
+        else:
+            ratio = pos_flow / neg_flow
+            self.lines.mfi[0] = 100.0 - 100.0 / (1.0 + ratio)
+
+
+class DeltaMFI(Indicator):
+    """Difference between two current-inclusive MFI periods plus color state."""
+
+    lines = ("color", "delta")
+    params = {"mfi_period1": 14, "mfi_period2": 50, "level": 50}
+
+    def __init__(self):
+        """Set up the two MFI sub-indicators and the regime thresholds."""
+        self.addminperiod(max(int(self.p.mfi_period1), int(self.p.mfi_period2)) + 3)
+        self.mfi1 = MoneyFlowIndex(self.data, period=int(self.p.mfi_period1))
+        self.mfi2 = MoneyFlowIndex(self.data, period=int(self.p.mfi_period2))
+        lvl = int(self.p.level)
+        self.max_level = 100 - (100 - lvl)
+        self.min_level = 100 - lvl
+
+    def next(self):
+        """Compute the MFI delta and assign a regime color.
+
+        Writes ``mfi_fast - mfi_slow`` to ``self.lines.delta`` and
+        colors ``0.0`` when the slow MFI is above the upper threshold
+        and the fast MFI is climbing, ``2.0`` when the slow MFI is
+        below the lower threshold and the fast MFI is falling, and
+        ``1.0`` (neutral) otherwise.
+        """
+        m1 = float(self.mfi1[0])
+        m2 = float(self.mfi2[0])
+        self.lines.delta[0] = m1 - m2
+        color = 1.0
+        if m2 > self.max_level and m1 > m2:
+            color = 0.0
+        if m2 < self.min_level and m1 < m2:
+            color = 2.0
+        self.lines.color[0] = color
+
+
+class MFISlowdown(Indicator):
+    """MFI extreme signal generator with optional slowdown detection."""
+
+    lines = ("sell", "buy")
+    params = {"mfi_period": 2, "level_max": 90.0, "level_min": 10.0, "seek_slowdown": True}
+
+    def __init__(self):
+        """Set up the MFI and ATR sub-indicators and the minimum period."""
+        self.addminperiod(max(int(self.p.mfi_period) + 2, 18))
+        self.mfi = MoneyFlowIndex(self.data, period=int(self.p.mfi_period))
+        self.atr = ATR(self.data, period=15)
+
+    def next(self):
+        """Emit ATR-buffered stop levels when MFI touches an extreme.
+
+        When ``seek_slowdown`` is enabled, a signal is only produced if
+        the MFI's previous bar value differs from the current value by
+        less than ``1.0`` (i.e. the MFI is stalling at the extreme).
+        The buy line is placed ``atr * 3/8`` below the low, and the
+        sell line ``atr * 3/8`` above the high. Lines are ``NaN`` when
+        no signal is produced.
+        """
+        self.lines.buy[0] = float("nan")
+        self.lines.sell[0] = float("nan")
+        m0 = float(self.mfi[0])
+        m1 = float(self.mfi[-1])
+        atr = float(self.atr[0])
+        if m0 >= float(self.p.level_max):
+            if (not self.p.seek_slowdown) or abs(m1 - m0) < 1.0:
+                self.lines.buy[0] = float(self.data.low[0]) - atr * 3.0 / 8.0
+        if m0 <= float(self.p.level_min):
+            if (not self.p.seek_slowdown) or abs(m1 - m0) < 1.0:
+                self.lines.sell[0] = float(self.data.high[0]) + atr * 3.0 / 8.0
+
+
+class MFIHistogramIndicator(Indicator):
+    """MFI value, midpoint and color-state histogram."""
+
+    lines = ("value", "midline", "color_state")
+    params = {"mfi_period": 14, "high_level": 60, "low_level": 40}
+
+    def __init__(self):
+        """Register the minimum period needed for the MFI lookback."""
+        self.addminperiod(self.p.mfi_period + 1)
+
+    def next(self):
+        """Write the MFI value, the 50 midline and the regime color.
+
+        For the first ``mfi_period`` bars the output is the neutral
+        ``(50.0, 50.0, 1.0)`` triple. After the buffer is warm, the
+        MFI is computed from typical prices and volume, falling back to
+        ``50.0`` when there is no flow information. The color is
+        ``0.0`` above ``high_level``, ``2.0`` below ``low_level``, and
+        ``1.0`` (neutral) in between.
+        """
+        if len(self.data) <= self.p.mfi_period:
+            self.lines.value[0] = 50.0
+            self.lines.midline[0] = 50.0
+            self.lines.color_state[0] = 1.0
+            return
+
+        positive_flow = 0.0
+        negative_flow = 0.0
+        for ago in range(self.p.mfi_period):
+            high = float(self.data.high[-ago])
+            low = float(self.data.low[-ago])
+            close = float(self.data.close[-ago])
+            prev_high = float(self.data.high[-ago - 1])
+            prev_low = float(self.data.low[-ago - 1])
+            prev_close = float(self.data.close[-ago - 1])
+            volume = float(self.data.volume[-ago])
+            typical = (high + low + close) / 3.0
+            prev_typical = (prev_high + prev_low + prev_close) / 3.0
+            raw_money_flow = typical * volume
+            if typical > prev_typical:
+                positive_flow += raw_money_flow
+            elif typical < prev_typical:
+                negative_flow += raw_money_flow
+
+        if negative_flow <= 1e-12:
+            mfi_value = 100.0 if positive_flow > 0 else 50.0
+        else:
+            money_ratio = positive_flow / negative_flow
+            mfi_value = 100.0 - (100.0 / (1.0 + money_ratio))
+
+        color = 1.0
+        if mfi_value > float(self.p.high_level):
+            color = 0.0
+        elif mfi_value < float(self.p.low_level):
+            color = 2.0
+
+        self.lines.value[0] = mfi_value
+        self.lines.midline[0] = 50.0
+        self.lines.color_state[0] = color

backtrader/indicators/mt5atr.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python
+"""MT5-compatible ATR Indicator Module.
+
+This module provides an ATR indicator that exactly matches MetaTrader 5's
+iATR() function, using Wilder's smoothing with MT5's seeding convention.
+
+Differences from standard backtrader ATR:
+  - Seed at bar index (period - 1) using TR[0..period-1]
+  - TR[0] = High[0] - Low[0] (no previous close available)
+  - Subsequent: ATR[i] = (ATR[i-1] * (period-1) + TR[i]) / period
+
+Classes:
+    MT5AverageTrueRange: ATR matching MT5's iATR() (alias: MT5ATR).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.atr = bt.indicators.MT5ATR(self.data, period=14)
+"""
+
+from . import Indicator
+
+
+class MT5AverageTrueRange(Indicator):
+    """Average True Range matching MetaTrader 5's iATR() implementation.
+
+    MT5 ATR algorithm:
+      - TR[0] = High[0] - Low[0]
+      - TR[i] = max(High[i], Close[i-1]) - min(Low[i], Close[i-1])  for i >= 1
+      - ATR[period-1] = SMA(TR[0..period-1])   (seed)
+      - ATR[i] = (ATR[i-1] * (period-1) + TR[i]) / period            for i >= period
+
+    See:
+      - https://www.mql5.com/en/docs/indicators/iatr
+    """
+
+    alias = ("MT5ATR",)
+
+    lines = ("atr",)
+    params = (("period", 14),)
+
+    def _plotlabel(self):
+        """Return the label segments used by the plot helper (just the period)."""
+        return [self.p.period]
+
+    def __init__(self):
+        """Wire the minimum period and cache the configured period on the instance.
+
+        The MT5 convention places the first ATR at bar index
+        ``period - 1``; the very first true range uses the high-low
+        range (no previous close), so the minimum period is just
+        ``period`` bars.
+        """
+        super().__init__()
+        # MT5 first ATR at bar index period-1, but TR needs prev close from bar 1,
+        # and bar 0's TR uses High-Low only. Min period = period bars total.
+        self.addminperiod(self.p.period)
+        self._period = self.p.period
+
+    @staticmethod
+    def _calc_tr(high, low, prev_close):
+        """Calculate True Range: max(high, prev_close) - min(low, prev_close)."""
+        return max(high, prev_close) - min(low, prev_close)
+
+    def nextstart(self):
+        """Seed ATR with SMA of first period TR values (MT5 convention)."""
+        period = self._period
+        tr_sum = 0.0
+        for i in range(period):
+            idx = -(period - 1 - i)  # oldest to newest: -(period-1), ..., -1, 0
+            if i == 0:
+                # First bar: no prev close, use High - Low
+                tr = self.data.high[idx] - self.data.low[idx]
+            else:
+                prev_idx = idx - 1
+                tr = self._calc_tr(
+                    self.data.high[idx], self.data.low[idx], self.data.close[prev_idx]
+                )
+            tr_sum += tr
+        self.lines.atr[0] = tr_sum / period
+
+    def next(self):
+        """ATR[i] = (ATR[i-1] * (period-1) + TR[i]) / period."""
+        tr = self._calc_tr(self.data.high[0], self.data.low[0], self.data.close[-1])
+        self.lines.atr[0] = (self.lines.atr[-1] * (self._period - 1) + tr) / self._period
+
+    def once(self, start, end):
+        """Calculate ATR in runonce mode (matches MT5 iATR exactly)."""
+        high = self.data.high.array
+        low = self.data.low.array
+        close = self.data.close.array
+        out = self.lines.atr.array
+        period = self._period
+
+        # Ensure output array is sized
+        while len(out) < end:
+            out.append(float("nan"))
+
+        n = min(end, len(high), len(low), len(close))
+
+        # Pre-fill with NaN before seed
+        for i in range(min(period - 1, n)):
+            out[i] = float("nan")
+
+        if n < period:
+            return
+
+        # Seed: SMA of TR[0..period-1]
+        seed_idx = period - 1
+        tr_sum = high[0] - low[0]  # TR[0] = High - Low (no prev close)
+        for i in range(1, period):
+            tr_sum += max(high[i], close[i - 1]) - min(low[i], close[i - 1])
+        prev_atr = tr_sum / period
+        out[seed_idx] = prev_atr
+
+        # Wilder smoothing for remaining bars
+        pm1 = period - 1  # period - 1
+        for i in range(period, n):
+            tr = max(high[i], close[i - 1]) - min(low[i], close[i - 1])
+            prev_atr = (prev_atr * pm1 + tr) / period
+            out[i] = prev_atr
+
+
+MT5ATR = MT5AverageTrueRange