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

backtrader/indicators/dma.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python
+"""DMA Indicator Module - Dickson Moving Average.
+
+This module provides the Dickson Moving Average (DMA) developed
+by Nathan Dickson, combining ZeroLag and Hull moving averages.
+
+Classes:
+    DicksonMovingAverage: DMA indicator (aliases: DMA, DicksonMA).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.dma = bt.indicators.DMA(self.data.close, period=20, gainlimit=50, hperiod=7)
+
+        def next(self):
+            if self.data.close[0] > self.dma[0]:
+                self.buy()
+            elif self.data.close[0] < self.dma[0]:
+                self.sell()
+"""
+
+import math
+
+from . import MovingAverageBase, ZeroLagIndicator
+from .ema import EMA
+from .hma import HMA
+
+
+class DicksonMovingAverage(MovingAverageBase):
+    """By Nathan Dickson
+
+    The *Dickson Moving Average* combines the ``ZeroLagIndicator`` (aka
+    *ErrorCorrecting* or *EC*) by *Ehlers*, and the ``HullMovingAverage`` to
+    try to deliver a result close to that of the *Jurik* Moving Averages
+
+    Formula:
+      - ec = ZeroLagIndicator(period, gainlimit)
+      - hma = HullMovingAverage(hperiod)
+
+      - dma = (ec + hma) / 2
+
+      - The default moving average for the *ZeroLagIndicator* is EMA, but can
+        be changed with the parameter ``_movav``
+
+        ::note:: the passed moving average must calculate alpha (and 1 - alpha)
+                and make them available as attributes ``alpha`` and ``alpha1``
+
+      - The second moving average can be changed from *Hull* to anything else with
+        the param *_hma*
+
+    See also:
+      - https://www.reddit.com/r/algotrading/comments/4xj3vh/dickson_moving_average
+    """
+
+    alias = (
+        "DMA",
+        "DicksonMA",
+    )
+    lines = ("dma",)
+    params = (
+        ("gainlimit", 50),
+        ("hperiod", 7),
+        ("_movav", EMA),
+        ("_hma", HMA),
+    )
+
+    def _plotlabel(self):
+        plabels = [self.p.period, self.p.gainlimit, self.p.hperiod]
+        plabels += [self.p._movav] * self.p.notdefault("_movav")
+        plabels += [self.p._hma] * self.p.notdefault("_hma")
+        return plabels
+
+    def __init__(self):
+        """Initialize the Dickson Moving Average.
+
+        Creates ZeroLag and Hull MA sub-indicators.
+        """
+        super().__init__()
+        self.ec = ZeroLagIndicator(
+            period=self.p.period, gainlimit=self.p.gainlimit, _movav=self.p._movav
+        )
+        self.hull = self.p._hma(period=self.p.hperiod)
+
+    def next(self):
+        """Calculate DMA for the current bar.
+
+        Formula: DMA = (ZeroLag + HMA) / 2
+        """
+        self.lines.dma[0] = (self.ec[0] + self.hull[0]) / 2.0
+
+    def once(self, start, end):
+        """Calculate DMA in runonce mode."""
+        ec_array = self.ec.lines[0].array
+        hull_array = self.hull.lines[0].array
+        larray = self.lines.dma.array
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        for i in range(start, min(end, len(ec_array), len(hull_array))):
+            ec_val = ec_array[i] if i < len(ec_array) else float("nan")
+            hull_val = hull_array[i] if i < len(hull_array) else float("nan")
+
+            if (
+                isinstance(ec_val, float)
+                and math.isnan(ec_val)
+                or isinstance(hull_val, float)
+                and math.isnan(hull_val)
+            ):
+                larray[i] = float("nan")
+            else:
+                larray[i] = (ec_val + hull_val) / 2.0

backtrader/indicators/dpo.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python
+"""DPO Indicator Module - Detrended Price Oscillator.
+
+This module provides the DPO (Detrended Price Oscillator) indicator
+developed by Joe DiNapoli to identify cycles by removing trend effects.
+
+Classes:
+    DetrendedPriceOscillator: DPO indicator (alias: DPO).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.dpo = bt.indicators.DPO(self.data, period=20)
+
+        def next(self):
+            if self.dpo[0] > 0:
+                self.buy()
+"""
+
+import math
+
+from . import Indicator, MovAv
+
+
+class DetrendedPriceOscillator(Indicator):
+    """
+    Defined by Joe DiNapoli in his book *"Trading with DiNapoli levels"*
+
+    It measures the price variations against a Moving Average (the trend)
+    and therefore removes the "trend" factor from the price.
+
+    Formula:
+      - movav = MovingAverage(close, period)
+      - dpo = close - movav(shifted period / 2 + 1)
+
+    See:
+      - http://en.wikipedia.org/wiki/Detrended_price_oscillator
+    """
+
+    # Named alias for invocation
+    alias = ("DPO",)
+
+    # Named output lines
+    lines = ("dpo",)
+
+    # Accepted parameters (and defaults) -
+    # MovAvg also parameter to allow experimentation
+    params = (("period", 20), ("movav", MovAv.Simple))
+
+    # Emphasize central 0.0 line in plot
+    plotinfo = {"plothlines": [0.0]}
+
+    # Indicator information after the name (in brackets)
+    def _plotlabel(self):
+        plabels = [self.p.period]
+        plabels += [self.p.movav] * self.p.notdefault("movav")
+        return plabels
+
+    def __init__(self):
+        """Initialize the DPO indicator.
+
+        Creates a moving average and calculates lookback period.
+        """
+        super().__init__()
+        self.ma = self.p.movav(self.data, period=self.p.period)
+        self.lookback = self.p.period // 2 - 1
+
+    def next(self):
+        """Calculate DPO for the current bar.
+
+        Formula: DPO = price - MA(lookback bars ago)
+        """
+        self.lines.dpo[0] = self.data[0] - self.ma[-self.lookback]
+
+    def once(self, start, end):
+        """Calculate DPO in runonce mode."""
+        darray = self.data.array
+        ma_array = self.ma.lines[0].array
+        larray = self.lines.dpo.array
+        lookback = self.lookback
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        for i in range(start, min(end, len(darray), len(ma_array))):
+            data_val = darray[i] if i < len(darray) else 0.0
+            ma_idx = i - lookback
+            if ma_idx >= 0 and ma_idx < len(ma_array):
+                ma_val = ma_array[ma_idx]
+            else:
+                ma_val = float("nan")
+
+            if isinstance(ma_val, float) and math.isnan(ma_val):
+                larray[i] = float("nan")
+            else:
+                larray[i] = data_val - ma_val

backtrader/indicators/dv2.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+"""DV2 Indicator Module - RSI(2) alternative.
+
+This module provides the DV2 indicator developed by David Varadi
+as an alternative to RSI(2).
+
+Classes:
+    DV2: DV2 indicator (RSI(2) alternative).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.dv2 = bt.indicators.DV2(self.data)
+
+        def next(self):
+            if self.dv2[0] > 50:
+                self.buy()
+"""
+
+from . import SMA, Indicator, PercentRank
+
+__all__ = ["DV2"]
+
+
+class DV2(Indicator):
+    """
+    RSI(2) alternative
+    Developed by David Varadi of http://cssanalytics.wordpress.com/
+
+    This seems to be the *Bounded* version.
+
+    See also:
+
+      - http://web.archive.org/web/20131216100741/http://quantingdutchman.wordpress.com/2010/08/06/dv2-indicator-for-amibroker/
+
+    """
+
+    params = (
+        ("period", 252),
+        ("maperiod", 2),
+        ("_movav", SMA),
+    )
+    lines = ("dv2",)
+
+    def __init__(self):
+        """Initialize the DV2 indicator calculation.
+
+        Calculates:
+        1. CHL = close / ((high + low) / 2)
+        2. DVU = moving average of CHL
+        3. DV2 = PercentRank(DVU) * 100
+        """
+        chl = self.data.close / ((self.data.high + self.data.low) / 2.0)
+        dvu = self.p._movav(chl, period=self.p.maperiod)
+        self.lines.dv2 = PercentRank(dvu, period=self.p.period) * 100
+        super().__init__()

backtrader/indicators/ema.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python
+"""EMA Indicator Module - Exponential Moving Average.
+
+This module provides the EMA (Exponential Moving Average) indicator
+which applies weighting factors that decrease exponentially.
+
+Classes:
+    ExponentialMovingAverage: EMA indicator (alias: EMA).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.ema = bt.indicators.EMA(self.data.close, period=20)
+
+        def next(self):
+            if self.data.close[0] > self.ema[0]:
+                self.buy()
+"""
+
+import math
+
+from ..utils.log_message import get_logger
+from . import MovingAverageBase
+
+logger = get_logger(__name__)
+
+
+class ExponentialMovingAverage(MovingAverageBase):
+    """
+    A Moving Average that smoothes data exponentially over time.
+
+    It is a subclass of SmoothingMovingAverage.
+
+      - self.smfactor -> 2 / (1 + period)
+      - self.smfactor1 -> `1 - self.smfactor`
+
+    Formula:
+      - movav = prev * (1.0 - smoothfactor) + newdata * smoothfactor
+
+    See also:
+      - http://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
+    """
+
+    alias = (
+        "EMA",
+        "MovingAverageExponential",
+    )
+    lines = ("ema",)
+
+    def __init__(self):
+        """Initialize the EMA indicator.
+
+        Calculates alpha and alpha1 smoothing factors:
+        - alpha = 2 / (1 + period)
+        - alpha1 = 1 - alpha
+        """
+        super().__init__()
+        self.alpha = 2.0 / (1.0 + self.p.period)
+        self.alpha1 = 1.0 - self.alpha
+
+    def nextstart(self):
+        """Seed the EMA with SMA of first period values."""
+        # Seed value: SMA of first period values
+        period = self.p.period
+        data_sum = 0.0
+        for i in range(period):
+            data_sum += self.data[-i]
+        self.lines[0][0] = data_sum / period
+
+    def next(self):
+        """Calculate EMA for the current bar.
+
+        Formula: EMA = previous_ema * alpha1 + current_price * alpha
+        """
+        # EMA formula: prev * alpha1 + current * alpha
+        self.lines[0][0] = self.lines[0][-1] * self.alpha1 + self.data[0] * self.alpha
+
+    def once(self, start, end):
+        """Calculate EMA in runonce mode"""
+        larray = self.lines[0].array
+        alpha = self.alpha
+        alpha1 = self.alpha1
+        period = self.p.period
+
+        # Ensure output array is properly sized
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        # CRITICAL FIX: For line-operation data sources, calculate the full
+        # input history needed to seed the EMA. Using this EMA's ``start``
+        # would skip the operation's warmup window and delay the seed.
+        if hasattr(self.data, "once") and hasattr(self.data, "operation"):
+            try:
+                self.data.once(0, end)
+            except Exception as e:
+                logger.debug("data.once() failed in EMA: %s", e)
+
+        darray = self.data.array
+        data_len = len(darray)
+        if data_len == 0:
+            return
+
+        # Find first valid (non-NaN) index for seed calculation
+        first_valid = 0
+        for i in range(data_len):
+            val = darray[i]
+            if not (isinstance(val, float) and math.isnan(val)):
+                first_valid = i
+                break
+
+        # Calculate seed index
+        seed_idx = first_valid + period - 1
+
+        # CRITICAL FIX: Pre-fill warmup period with NaN up to seed_idx
+        # This ensures indices before the seed are NaN, not 0.0
+        for i in range(min(seed_idx, data_len)):
+            larray[i] = float("nan")
+
+        if seed_idx < data_len:
+            seed_sum = 0.0
+            valid_count = 0
+            for i in range(first_valid, seed_idx + 1):
+                val = darray[i]
+                if not (isinstance(val, float) and math.isnan(val)):
+                    seed_sum += val
+                    valid_count += 1
+            if valid_count > 0:
+                prev = seed_sum / valid_count
+                larray[seed_idx] = prev
+            else:
+                return  # No valid data
+        else:
+            return  # Not enough data
+
+        # EMA is recursive - must calculate ALL values from seed onwards
+        for i in range(seed_idx + 1, min(end, data_len)):
+            current_val = darray[i]
+            if isinstance(current_val, float) and math.isnan(current_val):
+                larray[i] = float("nan")
+                continue
+            prev = prev * alpha1 + float(current_val) * alpha
+            larray[i] = prev
+
+
+EMA = ExponentialMovingAverage