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

backtrader/indicators/lrsi.py

@@ -0,0 +1,125 @@
+#!/usr/bin/env python
+"""Laguerre RSI Module - Laguerre filter-based RSI.
+
+This module provides the LaguerreRSI indicator defined by John F. Ehlers
+for faster reaction to price changes using Laguerre filters.
+
+Classes:
+    LaguerreRSI: Laguerre RSI indicator (alias: LRSI).
+    LaguerreFilter: Laguerre filter (alias: LAGF).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.lrsi = bt.indicators.LRSI(self.data, gamma=0.5)
+            self.lfilter = bt.indicators.LAGF(self.data, gamma=0.5)
+
+        def next(self):
+            if self.lrsi.lrsi[0] > 0.8:
+                self.sell()
+            elif self.lrsi.lrsi[0] < 0.2:
+                self.buy()
+"""
+
+from . import PeriodN
+
+__all__ = ["LaguerreRSI", "LRSI", "LaguerreFilter", "LAGF"]
+
+
+class LaguerreRSI(PeriodN):
+    """
+    Defined by John F. Ehlers in `Cybernetic Analysis for Stock and Futures`,
+    2004, published by Wiley. `ISBN: 978-0-471-46307-8`
+
+    The Laguerre RSI tries to implement a better RSI by providing a sort of
+    *Time Warp without Time Travel* using a Laguerre filter. This provides for
+    faster reactions to price changes
+
+    ``gamma`` is meant to have values between ``0.2`` and ``0.8``, with the
+    best balance found theoretically at the default of ``0.5``
+    """
+
+    alias = ("LRSI",)
+    lines = ("lrsi",)
+    params = (
+        ("gamma", 0.5),
+        ("period", 6),
+    )
+
+    plotinfo = {"plotymargin": 0.15, "plotyticks": [0.0, 0.2, 0.5, 0.8, 1.0]}
+
+    l0, l1, l2, l3 = 0.0, 0.0, 0.0, 0.0
+
+    def next(self):
+        """Calculate Laguerre RSI for the current bar.
+
+        Calculates L0-L3 Laguerre filter values and computes the
+        RSI-style ratio of upward changes to total changes.
+        """
+        l0_1 = self.l0  # cache previous intermediate values
+        l1_1 = self.l1
+        l2_1 = self.l2
+
+        g = self.p.gamma  # avoid more lookups
+        self.l0 = l0 = (1.0 - g) * self.data + g * l0_1
+        self.l1 = l1 = -g * l0 + l0_1 + g * l1_1
+        self.l2 = l2 = -g * l1 + l1_1 + g * l2_1
+        self.l3 = l3 = -g * l2 + l2_1 + g * self.l3
+
+        cu = 0.0
+        cd = 0.0
+        if l0 >= l1:
+            cu = l0 - l1
+        else:
+            cd = l1 - l0
+
+        if l1 >= l2:
+            cu += l1 - l2
+        else:
+            cd += l2 - l1
+
+        if l2 >= l3:
+            cu += l2 - l3
+        else:
+            cd += l3 - l2
+
+        den = cu + cd
+        self.lines.lrsi[0] = 1.0 if not den else cu / den
+
+
+class LaguerreFilter(PeriodN):
+    """
+    Defined by John F. Ehlers in `Cybernetic Analysis for Stock and Futures`,
+    2004, published by Wiley. `ISBN: 978-0-471-46307-8`
+
+    ``gamma`` is meant to have values between ``0.2`` and ``0.8``, with the
+    best balance found theoretically at the default of ``0.5``
+    """
+
+    alias = ("LAGF",)
+    lines = ("lfilter",)
+    params = (("gamma", 0.5),)
+    plotinfo = {"subplot": False}
+
+    l0, l1, l2, l3 = 0.0, 0.0, 0.0, 0.0
+
+    def next(self):
+        """Calculate Laguerre filter for the current bar.
+
+        Computes L0-L3 Laguerre filter values and outputs the
+        weighted average (l0 + 2*l1 + 2*l2 + l3) / 6.
+        """
+        l0_1 = self.l0  # cache previous intermediate values
+        l1_1 = self.l1
+        l2_1 = self.l2
+
+        g = self.p.gamma  # avoid more lookups
+        self.l0 = l0 = (1.0 - g) * self.data + g * l0_1
+        self.l1 = l1 = -g * l0 + l0_1 + g * l1_1
+        self.l2 = l2 = -g * l1 + l1_1 + g * l2_1
+        self.l3 = l3 = -g * l2 + l2_1 + g * self.l3
+        self.lines.lfilter[0] = (l0 + (2 * l1) + (2 * l2) + l3) / 6
+
+
+LRSI = LaguerreRSI
+LAGF = LaguerreFilter

backtrader/indicators/mabase.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python
+"""Moving Average Base Module - Core moving average infrastructure.
+
+This module provides the base classes and registration system for all
+moving average indicators in backtrader.
+
+Classes:
+    MovingAverage: Placeholder for all moving average types.
+    MovAv: Alias for MovingAverage.
+    MovingAverageBase: Base class for moving average indicators.
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.sma = bt.indicators.SMA(self.data.close, period=20)
+            self.ema = bt.indicators.EMA(self.data.close, period=12)
+            # Or using MovAv wrapper
+            self.wma = bt.indicators.MovAv.WMA(self.data.close, period=15)
+
+        def next(self):
+            if self.data.close[0] > self.sma[0]:
+                self.buy()
+            elif self.data.close[0] < self.sma[0]:
+                self.sell()
+"""
+
+from . import Indicator
+
+
+# Moving average class, used to set indicator names
+class MovingAverage:
+    """MovingAverage (alias MovAv)
+
+    A placeholder to gather all Moving Average Types in a single place.
+
+    Instantiating a SimpleMovingAverage can be achieved as follows::
+
+      sma = MovingAverage.Simple(self.data, period)
+
+    Or using the shorter aliases::
+
+      sma = MovAv.SMA(self.data, period)
+
+    or with the full (forwards and backwards) names:
+
+      sma = MovAv.SimpleMovingAverage(self.data, period)
+
+      sma = MovAv.MovingAverageSimple(self.data, period)
+
+    """
+
+    # Storage for moving average classes
+    _movavs: list = []
+
+    @classmethod
+    def register(cls, regcls):
+        """Register a moving average class with the placeholder.
+
+        Args:
+            regcls: The moving average class to register.
+
+        Sets the class name and aliases as attributes on the placeholder
+        for easy access (e.g., MovAv.SMA, MovAv.EMA).
+        """
+        # If indicator doesn't have _notregister or _notregister value is False, continue to register, otherwise return directly
+        if getattr(regcls, "_notregister", False):
+            return
+        # Add indicator class to be calculated
+        cls._movavs.append(regcls)
+        # Class name, and set class name as cls attribute, attribute value is the specific class
+        clsname = regcls.__name__
+        setattr(cls, clsname, regcls)
+
+        # Specific indicator alias, if indicator starts with MovingAverage, use latter value as alias, if ends with MovingAverage, use former value as alias
+        # If obtained alias is not empty string, then also set alias as attribute, attribute value is this class
+        clsalias = ""
+        if clsname.endswith("MovingAverage"):
+            clsalias = clsname.split("MovingAverage")[0]
+        elif clsname.startswith("MovingAverage"):
+            clsalias = clsname.split("MovingAverage")[1]
+
+        if clsalias:
+            setattr(cls, clsalias, regcls)
+
+        # CRITICAL FIX: Process the alias attribute if it exists
+        # Many indicators define their own aliases like alias = ("SMA", "SimpleMovingAverage")
+        if hasattr(regcls, "alias"):
+            aliases = regcls.alias
+            # Support both tuple and single string
+            if isinstance(aliases, str):
+                aliases = (aliases,)
+            # Register each alias
+            for alias_name in aliases:
+                if alias_name and isinstance(alias_name, str):
+                    setattr(cls, alias_name, regcls)
+
+
+# Alias for moving average
+class MovAv(MovingAverage):
+    """Alias for MovingAverage.
+
+    Provides a shorter name for accessing moving average types.
+    """
+
+    # alias
+
+
+# Base class for moving average, add parameters and plot settings - refactored to remove metaclass
+class MovingAverageBase(Indicator):
+    """Base class for all moving average indicators.
+
+    Provides common initialization with minimum period management and
+    automatic registration with the MovingAverage placeholder.
+
+    Attributes:
+        params: Default period parameter (30).
+        plotinfo: Default to plot on main chart (subplot=False).
+    """
+
+    # Parameters
+    params = (("period", 30),)
+    # Plot on main chart by default
+    plotinfo = {"subplot": False}
+
+    def __init__(self):
+        """Initialize moving average and set minimum period"""
+        super().__init__()
+
+        # CRITICAL FIX: Inherit minperiod from data source BEFORE adding own period
+        # This ensures nested indicators (like EMA applied to MACD line) properly accumulate minperiods
+        if hasattr(self, "datas") and self.datas:
+            data_minperiods = [getattr(d, "_minperiod", 1) for d in self.datas if d is not None]
+            if data_minperiods:
+                data_max = max(data_minperiods)
+                if data_max > self._minperiod:
+                    self._minperiod = data_max
+
+        # CRITICAL FIX: Set the minimum period based on the period parameter
+        # This ensures the indicator doesn't start calculating until enough data is available
+        self.addminperiod(self.p.period)
+
+    def __init_subclass__(cls, **kwargs):
+        """Register moving average classes automatically"""
+        super().__init_subclass__(**kwargs)
+        # Register any MovingAverage with the placeholder to allow the automatic
+        # creation of envelopes and oscillators
+        MovingAverage.register(cls)

backtrader/indicators/macd.py

@@ -0,0 +1,322 @@
+#!/usr/bin/env python
+"""MACD Indicator Module - Moving Average Convergence Divergence.
+
+This module provides the MACD (Moving Average Convergence Divergence)
+indicator developed by Gerald Appel in the 1970s for trend following.
+
+Classes:
+    MACD: MACD indicator with signal line.
+    MACDHisto: MACD with histogram (alias: MACDHistogram).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.macd = bt.indicators.MACD(self.data)
+            self.macd_hist = bt.indicators.MACDHisto(self.data)
+
+        def next(self):
+            # MACD crossover strategy
+            if self.macd.macd[0] > self.macd.signal[0]:
+                self.buy()
+            elif self.macd.macd[0] < self.macd.signal[0]:
+                self.sell()
+"""
+
+import math
+
+from . import Indicator, MovAv
+
+
+def _finite(value):
+    return value is not None and not (isinstance(value, float) and not math.isfinite(value))
+
+
+class MACD(Indicator):
+    """
+    Moving Average Convergence Divergence. Defined by Gerald Appel in the 70s.
+
+    It measures the distance of a short and a long term moving average to
+    try to identify the trend.
+
+    A second lagging moving average over the convergence-divergence should
+    provide a "signal" upon being crossed by the macd
+
+    Formula:
+      - macd = ema(data, me1_period) - ema(data, me2_period)
+      - signal = ema(macd, signal_period)
+
+    See:
+      - http://en.wikipedia.org/wiki/MACD
+    """
+
+    lines = (
+        "macd",
+        "signal",
+    )
+    params = (
+        ("period_me1", 12),
+        ("period_me2", 26),
+        ("period_signal", 9),
+        ("movav", MovAv.Exponential),
+    )
+
+    plotinfo = {"plothlines": [0.0]}
+    plotlines = {"signal": {"ls": "--"}}
+
+    def _plotlabel(self):
+        plabels = super()._plotlabel()
+        if self.p.isdefault("movav"):
+            plabels.remove(self.p.movav)
+        return plabels
+
+    def __init__(self):
+        """Initialize the MACD indicator.
+
+        Creates moving averages and sets up signal line calculation.
+        """
+        super().__init__()
+        # Store the EMAs as sub-indicators
+        self.me1 = self.p.movav(self.data, period=self.p.period_me1)
+        self.me2 = self.p.movav(self.data, period=self.p.period_me2)
+        # Preserve master's aliases without adding extra indicator output lines.
+        self.lines.me1 = self.me1
+        self.lines.me2 = self.me2
+
+        # Calculate minperiod
+        self.macd_minperiod = max(self.p.period_me1, self.p.period_me2)
+        signal_minperiod = self.macd_minperiod + self.p.period_signal - 1
+        self._minperiod = max(self._minperiod, signal_minperiod)
+
+        # CRITICAL FIX: Propagate minperiod to lines so that other indicators
+        # using these lines as data sources will inherit the correct minperiod
+        for line in self.lines:
+            line.updateminperiod(self._minperiod)
+
+        # Signal line alpha for EMA calculation
+        self.signal_alpha = 2.0 / (1.0 + self.p.period_signal)
+        self.signal_alpha1 = 1.0 - self.signal_alpha
+
+    def prenext(self):
+        """Calculate MACD during warmup period.
+
+        Ensures MACD values are available for signal line seeding.
+        """
+        try:
+            me1_val = self.me1[0]
+            me2_val = self.me2[0]
+        except (IndexError, TypeError):
+            self.lines.macd[0] = float("nan")
+            return
+
+        if not (_finite(me1_val) and _finite(me2_val)):
+            self.lines.macd[0] = float("nan")
+            return
+
+        self.lines.macd[0] = me1_val - me2_val
+
+    def nextstart(self):
+        """Calculate MACD and seed signal line on first valid bar.
+
+        Computes MACD and seeds signal with SMA of MACD values.
+        """
+        try:
+            me1_val = self.me1[0]
+            me2_val = self.me2[0]
+        except (IndexError, TypeError):
+            self.lines.macd[0] = float("nan")
+            self.lines.signal[0] = float("nan")
+            return
+
+        if not (_finite(me1_val) and _finite(me2_val)):
+            self.lines.macd[0] = float("nan")
+            self.lines.signal[0] = float("nan")
+            return
+
+        macd_val = me1_val - me2_val
+        self.lines.macd[0] = macd_val
+        # # Seed signal with MACD value
+        # self.lines.signal[0] = macd_val
+        signal_period = self.p.period_signal
+        macd_sum = 0.0
+        macd_count = 0
+        for i in range(signal_period):
+            try:
+                value = self.lines.macd[-i]
+            except (IndexError, TypeError):
+                value = float("nan")
+            if _finite(value):
+                macd_sum += value
+                macd_count += 1
+        self.lines.signal[0] = macd_sum / macd_count if macd_count else macd_val
+
+    def next(self):
+        """Calculate MACD and signal line for the current bar.
+
+        MACD = me1 - me2
+        Signal = EMA(MACD)
+        """
+        try:
+            me1_val = self.me1[0]
+            me2_val = self.me2[0]
+        except (IndexError, TypeError):
+            self.lines.macd[0] = float("nan")
+            self.lines.signal[0] = float("nan")
+            return
+
+        if not (_finite(me1_val) and _finite(me2_val)):
+            self.lines.macd[0] = float("nan")
+            self.lines.signal[0] = float("nan")
+            return
+
+        macd_val = me1_val - me2_val
+        self.lines.macd[0] = macd_val
+        # Calculate signal = EMA of MACD
+        try:
+            previous_signal = self.lines.signal[-1]
+        except (IndexError, TypeError):
+            previous_signal = macd_val
+
+        if not _finite(previous_signal):
+            previous_signal = macd_val
+
+        self.lines.signal[0] = previous_signal * self.signal_alpha1 + macd_val * self.signal_alpha
+
+    def once(self, start, end):
+        """Calculate MACD in runonce mode"""
+        me1_array = self.me1.lines[0].array
+        me2_array = self.me2.lines[0].array
+        macd_array = self.lines.macd.array
+        signal_array = self.lines.signal.array
+
+        signal_alpha = self.signal_alpha
+        signal_alpha1 = self.signal_alpha1
+        macd_minperiod = self.macd_minperiod
+        signal_period = self.p.period_signal
+
+        # Ensure arrays are properly sized
+        while len(macd_array) < end:
+            macd_array.append(float("nan"))
+        while len(signal_array) < end:
+            signal_array.append(float("nan"))
+
+        # Pre-fill warmup period with NaN
+        for i in range(min(macd_minperiod - 1, len(me1_array))):
+            macd_array[i] = float("nan")
+            signal_array[i] = float("nan")
+
+        # Calculate MACD values for all data points from macd_minperiod onwards
+        for i in range(macd_minperiod - 1, min(end, len(me1_array), len(me2_array))):
+            me1_val = me1_array[i]
+            me2_val = me2_array[i]
+
+            # Handle NaN values
+            if isinstance(me1_val, float) and math.isnan(me1_val):
+                macd_array[i] = float("nan")
+                continue
+            if isinstance(me2_val, float) and math.isnan(me2_val):
+                macd_array[i] = float("nan")
+                continue
+
+            macd_array[i] = me1_val - me2_val
+
+        # Calculate signal line (EMA of MACD)
+        signal_start = macd_minperiod + signal_period - 2
+
+        # Pre-fill signal warmup with NaN
+        for i in range(macd_minperiod - 1, min(signal_start, len(signal_array))):
+            signal_array[i] = float("nan")
+
+        # Seed signal with SMA of first signal_period MACD values
+        if signal_start < len(macd_array) and signal_start >= 0:
+            seed_sum = 0.0
+            seed_count = 0
+            for j in range(macd_minperiod - 1, signal_start + 1):
+                if j < len(macd_array):
+                    val = macd_array[j]
+                    if not (isinstance(val, float) and math.isnan(val)):
+                        seed_sum += val
+                        seed_count += 1
+            prev_signal = seed_sum / seed_count if seed_count > 0 else 0.0
+            signal_array[signal_start] = prev_signal
+        else:
+            prev_signal = 0.0
+
+        # Calculate signal EMA for all subsequent data points
+        for i in range(signal_start + 1, min(end, len(macd_array))):
+            macd_val = macd_array[i]
+            if isinstance(macd_val, float) and math.isnan(macd_val):
+                signal_array[i] = float("nan")
+                continue
+
+            prev_signal = prev_signal * signal_alpha1 + macd_val * signal_alpha
+            signal_array[i] = prev_signal
+
+
+class MACDHisto(MACD):
+    """
+    Subclass of MACD which adds a "histogram" of the difference between the
+    macd and signal lines
+
+    Formula:
+      - histo = macd - signal
+
+    See:
+      - http://en.wikipedia.org/wiki/MACD
+    """
+
+    alias = ("MACDHistogram",)
+
+    lines = ("histo",)
+    plotlines = {"histo": {"_method": "bar", "alpha": 0.50, "width": 1.0}}
+
+    def __init__(self):
+        """Initialize the MACD Histogram indicator.
+
+        Extends MACD with histogram line.
+        """
+        super().__init__()
+
+    def nextstart(self):
+        """Calculate MACD Histogram on first valid bar.
+
+        Histogram = MACD - Signal.
+        """
+        super().nextstart()
+        self.lines.histo[0] = self.lines.macd[0] - self.lines.signal[0]
+
+    def next(self):
+        """Calculate MACD Histogram for the current bar.
+
+        Histogram = MACD - Signal.
+        """
+        super().next()
+        self.lines.histo[0] = self.lines.macd[0] - self.lines.signal[0]
+
+    def once(self, start, end):
+        """Calculate MACD Histogram in runonce mode.
+
+        Computes histogram as MACD minus signal across all bars.
+        """
+        super().once(start, end)
+        macd_array = self.lines.macd.array
+        signal_array = self.lines.signal.array
+        histo_array = self.lines.histo.array
+
+        # Ensure histo array is sized
+        while len(histo_array) < end:
+            histo_array.append(float("nan"))
+
+        # Calculate histogram
+        for i in range(start, min(end, len(macd_array), len(signal_array))):
+            macd_val = macd_array[i] if i < len(macd_array) else 0.0
+            signal_val = signal_array[i] if i < len(signal_array) else 0.0
+
+            if (
+                isinstance(macd_val, float)
+                and math.isnan(macd_val)
+                or isinstance(signal_val, float)
+                and math.isnan(signal_val)
+            ):
+                histo_array[i] = float("nan")
+            else:
+                histo_array[i] = macd_val - signal_val