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

backtrader/indicators/demarker.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python
+"""DeMarker, Williams %R and related delta/slowdown indicators."""
+
+from . import Indicator
+from .atr import ATR
+from .rsi import RSI
+from .williams import WilliamsR
+
+__all__ = [
+    "DeMarker",
+    "DeMarkerIndicator",
+    "DeMarkerRollingIndicator",
+    "DeltaRSI",
+    "DeltaWPR",
+    "WilliamsPercentR",
+    "WPRHistogramIndicator",
+    "WPRSlowdown",
+]
+
+
+class DeMarker(Indicator):
+    """DeMarker oscillator with both ``demarker`` and ``dem`` output lines."""
+
+    lines = ("demarker", "dem")
+    params = (("period", 14), ("zero_value", 0.5))
+
+    def __init__(self):
+        """Register the rolling window needed by the DeMarker formula."""
+        self.addminperiod(self.p.period + 1)
+
+    def next(self):
+        """Compute the DeMarker value for the current bar.
+
+        Sums the positive high-deltas (``max(high_now - high_prev, 0)``)
+        and positive low-deltas (``max(low_prev - low_now, 0)``) across
+        the configured period, then writes ``de_max_sum / (de_max_sum +
+        de_min_sum)`` to both output lines. When the denominator is
+        zero the configurable ``zero_value`` is used instead.
+        """
+        de_max_sum = 0.0
+        de_min_sum = 0.0
+        for i in range(self.p.period):
+            high_now = float(self.data.high[-i])
+            high_prev = float(self.data.high[-(i + 1)])
+            low_now = float(self.data.low[-i])
+            low_prev = float(self.data.low[-(i + 1)])
+            de_max_sum += max(high_now - high_prev, 0.0)
+            de_min_sum += max(low_prev - low_now, 0.0)
+        denom = de_max_sum + de_min_sum
+        value = float(self.p.zero_value) if denom == 0 else de_max_sum / denom
+        self.lines.demarker[0] = value
+        self.lines.dem[0] = value
+
+
+class DeMarkerIndicator(DeMarker):
+    """Compatibility DeMarker variant whose zero-denominator value is ``0.0``."""
+
+    params = (("period", 14), ("zero_value", 0.0))
+
+
+class DeMarkerRollingIndicator(Indicator):
+    """Rolling-buffer DeMarker variant with ``0.5`` fallback."""
+
+    lines = ("demarker", "dem")
+    params = {"period": 14}
+
+    def __init__(self):
+        """Register the minimum period and prepare the rolling move buffers."""
+        self.addminperiod(int(self.p.period) + 1)
+        self._up_moves = []
+        self._down_moves = []
+
+    def next(self):
+        """Append today's up/down move and emit the rolling DeMarker value.
+
+        Maintains two Python lists capped at ``period`` entries. Until
+        the buffer is full, both output lines are set to ``NaN``;
+        afterwards the DeMarker formula is applied and the result is
+        written to both lines. A zero denominator falls back to ``0.5``.
+        """
+        up_move = max(float(self.data.high[0]) - float(self.data.high[-1]), 0.0)
+        down_move = max(float(self.data.low[-1]) - float(self.data.low[0]), 0.0)
+        self._up_moves.append(up_move)
+        self._down_moves.append(down_move)
+        period = int(self.p.period)
+        if len(self._up_moves) > period:
+            self._up_moves.pop(0)
+            self._down_moves.pop(0)
+        if len(self._up_moves) < period:
+            self.lines.demarker[0] = float("nan")
+            self.lines.dem[0] = float("nan")
+            return
+        up_sum = sum(self._up_moves)
+        down_sum = sum(self._down_moves)
+        denom = up_sum + down_sum
+        value = 0.5 if denom == 0.0 else up_sum / denom
+        self.lines.demarker[0] = value
+        self.lines.dem[0] = value
+
+
+class WilliamsPercentR(Indicator):
+    """Williams %R with line name ``wpr`` and zero-denominator fallback ``0``."""
+
+    lines = ("wpr",)
+    params = {"period": 14}
+
+    def __init__(self):
+        """Register the minimum period needed for the lookback window."""
+        self.addminperiod(self.p.period)
+
+    def next(self):
+        """Compute Williams %R using the highest-high / lowest-low window.
+
+        When the denominator ``highest - lowest`` is zero (flat window)
+        the value is forced to ``0.0``; otherwise the classic
+        ``-100 * (highest - close) / (highest - lowest)`` formula is
+        written to ``self.lines.wpr``.
+        """
+        period = int(self.p.period)
+        highest = max(float(self.data.high[-i]) for i in range(period))
+        lowest = min(float(self.data.low[-i]) for i in range(period))
+        denom = highest - lowest
+        if denom == 0.0:
+            self.lines.wpr[0] = 0.0
+            return
+        self.lines.wpr[0] = -100.0 * (highest - float(self.data.close[0])) / denom
+
+
+class DeltaRSI(Indicator):
+    """Difference between fast/slow RSI and a regime color line."""
+
+    lines = ("color", "delta")
+    params = {"rsi_period1": 14, "rsi_period2": 50, "level": 50}
+
+    def __init__(self):
+        """Set up the fast/slow RSI sub-indicators and regime thresholds."""
+        self.addminperiod(max(int(self.p.rsi_period1), int(self.p.rsi_period2)) + 3)
+        self.rsi1 = RSI(self.data, period=int(self.p.rsi_period1))
+        self.rsi2 = RSI(self.data, period=int(self.p.rsi_period2))
+        lvl = int(self.p.level)
+        self.max_level = 100 - (100 - lvl)
+        self.min_level = 100 - lvl
+
+    def next(self):
+        """Compute the RSI delta and assign a regime color.
+
+        The fast RSI is subtracted from the slow RSI and written to
+        ``self.lines.delta``. The color is ``0.0`` when the slow RSI is
+        above its upper threshold and the fast RSI is climbing,
+        ``2.0`` when the slow RSI is below its lower threshold and the
+        fast RSI is falling, and ``1.0`` (neutral) otherwise.
+        """
+        r1 = float(self.rsi1[0])
+        r2 = float(self.rsi2[0])
+        self.lines.delta[0] = r1 - r2
+        color = 1.0
+        if r2 > self.max_level and r1 > r2:
+            color = 0.0
+        if r2 < self.min_level and r1 < r2:
+            color = 2.0
+        self.lines.color[0] = color
+
+
+class DeltaWPR(Indicator):
+    """Difference between fast/slow Williams %R and a regime color line."""
+
+    lines = ("color", "delta")
+    params = {"wpr_period1": 14, "wpr_period2": 30, "level": -50}
+
+    def __init__(self):
+        """Set up the fast/slow Williams %R sub-indicators and thresholds."""
+        self.addminperiod(max(int(self.p.wpr_period1), int(self.p.wpr_period2)) + 3)
+        self.wpr1 = WilliamsR(self.data, period=int(self.p.wpr_period1))
+        self.wpr2 = WilliamsR(self.data, period=int(self.p.wpr_period2))
+        self.max_level = int(self.p.level)
+        self.min_level = int(-100 - self.p.level)
+
+    def next(self):
+        """Compute the Williams %R delta and assign a regime color.
+
+        The fast WPR is subtracted from the slow WPR and written to
+        ``self.lines.delta``. The color is ``0.0`` when the slow WPR
+        is above its upper threshold and the fast WPR is climbing,
+        ``2.0`` when the slow WPR is below its lower threshold and the
+        fast WPR is falling, and ``1.0`` (neutral) otherwise.
+        """
+        w1 = float(self.wpr1[0])
+        w2 = float(self.wpr2[0])
+        self.lines.delta[0] = w1 - w2
+        color = 1.0
+        if w2 > self.max_level and w1 > w2:
+            color = 0.0
+        if w2 < self.min_level and w1 < w2:
+            color = 2.0
+        self.lines.color[0] = color
+
+
+class WPRSlowdown(Indicator):
+    """Williams %R extreme slowdown signal generator."""
+
+    lines = ("sell", "buy")
+    params = {"wpr_period": 12, "level_max": -20.0, "level_min": -80.0, "seek_slowdown": True}
+
+    def __init__(self):
+        """Set up the Williams %R and ATR sub-indicators and the min period."""
+        self.addminperiod(max(int(self.p.wpr_period) + 2, 18))
+        self.wpr = WilliamsR(self.data, period=int(self.p.wpr_period))
+        self.atr = ATR(self.data, period=15)
+
+    def next(self):
+        """Emit ATR-buffered stop levels when WPR touches an extreme.
+
+        When ``seek_slowdown`` is enabled, a signal is only emitted if
+        the WPR value at the previous bar differs from the current
+        value by less than ``1.0`` (i.e. the WPR 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")
+        w0 = float(self.wpr[0])
+        w1 = float(self.wpr[-1])
+        atr = float(self.atr[0])
+        if w0 >= float(self.p.level_max):
+            if (not self.p.seek_slowdown) or abs(w1 - w0) < 1.0:
+                self.lines.buy[0] = float(self.data.low[0]) - atr * 3.0 / 8.0
+        if w0 <= float(self.p.level_min):
+            if (not self.p.seek_slowdown) or abs(w1 - w0) < 1.0:
+                self.lines.sell[0] = float(self.data.high[0]) + atr * 3.0 / 8.0
+
+
+class WPRHistogramIndicator(Indicator):
+    """Williams %R value, midpoint and color-state histogram."""
+
+    lines = ("value", "midline", "color_state")
+    params = {"wpr_period": 14, "high_level": -30, "low_level": -70}
+
+    def __init__(self):
+        """Register the minimum period needed for the WPR lookback."""
+        self.addminperiod(self.p.wpr_period)
+
+    def next(self):
+        """Write the WPR value, the -50 midline and the regime color.
+
+        The ``value`` line carries the standard Williams %R formula
+        (with a ``-50`` fallback when the lookback is flat). The
+        ``midline`` is fixed at ``-50``. The ``color_state`` is ``0.0``
+        when the value is above ``high_level``, ``2.0`` when it is
+        below ``low_level``, and ``1.0`` (neutral) in between.
+        """
+        period = int(self.p.wpr_period)
+        highest_high = max(float(self.data.high[-i]) for i in range(period))
+        lowest_low = min(float(self.data.low[-i]) for i in range(period))
+        close = float(self.data.close[0])
+        denom = highest_high - lowest_low
+        if abs(denom) <= 1e-12:
+            value = -50.0
+        else:
+            value = -100.0 * (highest_high - close) / denom
+
+        color = 1.0
+        if value > float(self.p.high_level):
+            color = 0.0
+        elif value < float(self.p.low_level):
+            color = 2.0
+
+        self.lines.value[0] = value
+        self.lines.midline[0] = -50.0
+        self.lines.color_state[0] = color

backtrader/indicators/deviation.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python
+"""Deviation Indicator Module - Standard deviation and mean deviation.
+
+This module provides deviation indicators for measuring data dispersion.
+
+Classes:
+    StandardDeviation: Standard deviation indicator (alias: StdDev).
+    MeanDeviation: Mean absolute deviation (alias: MeanDev).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.sma = bt.indicators.SMA(self.data.close, period=20)
+            self.stddev = bt.indicators.StdDev(self.data.close, period=20)
+            self.upper_band = self.sma + 2 * self.stddev
+            self.lower_band = self.sma - 2 * self.stddev
+
+        def next(self):
+            if self.data.close[0] > self.upper_band[0]:
+                self.sell()
+            elif self.data.close[0] < self.lower_band[0]:
+                self.buy()
+"""
+
+import math
+
+from . import Indicator, MovAv
+
+
+class StandardDeviation(Indicator):
+    """
+    Calculates the standard deviation of the passed data for a given period
+
+    Note:
+      - If 2 datas are provided as parameters, the second is considered to be the
+        mean of the first
+
+      - ``safepow`` (default: False) If this parameter is True, the standard
+        deviation will be calculated as pow (abs(meansq - sqmean), 0.5) to
+        safeguard for possible negative results of ``meansq - sqmean`` caused by
+        the floating point representation.
+
+    Formula:
+      - meansquared = SimpleMovingAverage(pow (data, 2), period)
+      - squaredmean = pow(SimpleMovingAverage(data, period), 2)
+      - stddev = pow(meansquared - squaredmean, 0.5) # square root
+
+    See:
+      - http://en.wikipedia.org/wiki/Standard_deviation
+    """
+
+    alias = ("StdDev",)
+
+    lines = ("stddev",)
+    params = (
+        ("period", 20),
+        ("movav", MovAv.Simple),
+        ("safepow", True),
+    )
+
+    def _plotlabel(self):
+        plabels = [self.p.period]
+        plabels += [self.p.movav] * self.p.notdefault("movav")
+        return plabels
+
+    def __init__(self):
+        """Initialize the Standard Deviation indicator."""
+        super().__init__()
+        self.addminperiod(self.p.period)
+        self._use_external_mean = len(self.datas) > 1
+        self._mean_prev = None
+        self._meansq_prev = None
+
+    def _movav_kind(self):
+        movav = self.p.movav
+        names = {getattr(movav, "__name__", "")}
+        aliases = getattr(movav, "alias", ())
+        if isinstance(aliases, str):
+            names.add(aliases)
+        else:
+            names.update(aliases)
+
+        if names.intersection(
+            {
+                "SmoothedMovingAverage",
+                "SMMA",
+                "WilderMA",
+                "MovingAverageSmoothed",
+                "MovingAverageWilder",
+                "ModifiedMovingAverage",
+                "Smoothed",
+            }
+        ):
+            return "smoothed"
+
+        if names.intersection(
+            {"ExponentialMovingAverage", "EMA", "MovingAverageExponential", "Exponential"}
+        ):
+            return "exponential"
+
+        return "simple"
+
+    def _finish(self, meansq, mean):
+        diff = meansq - mean * mean
+        if self.p.safepow:
+            diff = abs(diff)
+        return math.sqrt(max(0.0, diff))
+
+    def next(self):
+        """Calculate standard deviation for the current bar."""
+        period = self.p.period
+        if len(self) < period:
+            self.lines.stddev[0] = float("nan")
+            return
+
+        kind = self._movav_kind()
+        values = [float(self.data[i]) for i in range(1 - period, 1)]
+        if any(value != value for value in values):
+            self.lines.stddev[0] = float("nan")
+            return
+
+        if kind == "smoothed":
+            alpha = 1.0 / period
+        elif kind == "exponential":
+            alpha = 2.0 / (1.0 + period)
+        else:
+            alpha = None
+
+        if alpha is None or self._meansq_prev is None:
+            meansq = math.fsum(value * value for value in values) / period
+        else:
+            meansq = (
+                self._meansq_prev * (1.0 - alpha)
+                + float(self.data[0]) * float(self.data[0]) * alpha
+            )
+
+        if self._use_external_mean:
+            mean = float(self.data1[0])
+        elif alpha is None or self._mean_prev is None:
+            mean = math.fsum(values) / period
+        else:
+            mean = self._mean_prev * (1.0 - alpha) + float(self.data[0]) * alpha
+
+        self._meansq_prev = meansq
+        if not self._use_external_mean:
+            self._mean_prev = mean
+
+        self.lines.stddev[0] = self._finish(meansq, mean)
+
+    def once(self, start, end):
+        """Calculate standard deviation in runonce mode."""
+        darray = self.data.array
+        larray = self.lines.stddev.array
+        period = self.p.period
+        actual_end = min(end, len(darray))
+        nan_val = float("nan")
+
+        while len(larray) < end:
+            larray.append(nan_val)
+
+        for i in range(min(period - 1, len(larray), actual_end)):
+            larray[i] = nan_val
+
+        if self._use_external_mean:
+            if hasattr(self.data1, "once"):
+                self.data1.once(0, end)
+            mean_array = self.data1.array
+        else:
+            mean_array = None
+
+        kind = self._movav_kind()
+        if kind == "smoothed":
+            alpha = 1.0 / period
+        elif kind == "exponential":
+            alpha = 2.0 / (1.0 + period)
+        else:
+            alpha = None
+
+        if alpha is None:
+            for i in range(period - 1, actual_end):
+                start_idx = i - period + 1
+                end_idx = i + 1
+                window = darray[start_idx:end_idx]
+                if len(window) != period or any(value != value for value in window):
+                    larray[i] = nan_val
+                    continue
+
+                meansq = math.fsum(value * value for value in window) / period
+                if mean_array is not None:
+                    if i >= len(mean_array) or mean_array[i] != mean_array[i]:
+                        larray[i] = nan_val
+                        continue
+                    mean = mean_array[i]
+                else:
+                    mean = math.fsum(window) / period
+
+                larray[i] = self._finish(meansq, mean)
+            return
+
+        prev_mean = None
+        prev_meansq = None
+        for i in range(period - 1, actual_end):
+            if i == period - 1:
+                window = darray[0:period]
+                if len(window) != period or any(value != value for value in window):
+                    larray[i] = nan_val
+                    continue
+                prev_meansq = math.fsum(value * value for value in window) / period
+                if mean_array is None:
+                    prev_mean = math.fsum(window) / period
+            else:
+                value = float(darray[i])
+                if value != value or prev_meansq is None:
+                    larray[i] = nan_val
+                    continue
+                prev_meansq = prev_meansq * (1.0 - alpha) + value * value * alpha
+                if mean_array is None:
+                    if prev_mean is None:
+                        larray[i] = nan_val
+                        continue
+                    prev_mean = prev_mean * (1.0 - alpha) + value * alpha
+
+            if mean_array is not None:
+                if i >= len(mean_array) or mean_array[i] != mean_array[i]:
+                    larray[i] = nan_val
+                    continue
+                mean = mean_array[i]
+            else:
+                mean = prev_mean
+
+            larray[i] = self._finish(prev_meansq, mean)
+
+
+# Average deviation
+class MeanDeviation(Indicator):
+    """MeanDeviation (alias MeanDev)
+
+    Calculates the Mean Deviation of the passed data for a given period
+
+    Note:
+      - If 2 datas are provided as parameters, the second is considered to be the
+        mean of the first
+
+    Formula:
+      - mean = MovingAverage(data, period) (or provided mean)
+      - absdeviation = abs (data - mean)
+      - meandev = MovingAverage(absdeviation, period)
+
+    See:
+      - https://en.wikipedia.org/wiki/Average_absolute_deviation
+    """
+
+    alias = ("MeanDev",)
+
+    lines = ("meandev",)
+    params = (
+        ("period", 20),
+        ("movav", MovAv.Simple),
+    )
+
+    def _plotlabel(self):
+        plabels = [self.p.period]
+        plabels += [self.p.movav] * self.p.notdefault("movav")
+        return plabels
+
+    def __init__(self):
+        """Initialize the Mean Deviation indicator.
+
+        Creates the mean deviation calculation using either
+        external mean or calculated moving average.
+        """
+        # CRITICAL: Match master branch behavior
+        # If 2 datas are provided, the 2nd is considered to be the mean of the first
+        if len(self.datas) > 1:
+            mean = self.data1
+        else:
+            mean = self.p.movav(self.data, period=self.p.period)
+
+        absdev = abs(self.data - mean)
+        self.lines.meandev = self.p.movav(absdev, period=self.p.period)
+
+
+StdDev = StandardDeviation
+MeanDev = MeanDeviation