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

backtrader/indicators/williams.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python
+"""Williams Indicator Module - Williams %R indicator.
+
+This module provides the WilliamsR indicator developed by Larry
+Williams to show overbought/oversold conditions.
+
+Classes:
+    WilliamsR: Williams %R indicator.
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.williamsr = bt.indicators.WilliamsR(self.data, period=14)
+
+        def next(self):
+            # Williams %R above -20 indicates overbought
+            if self.williamsr.percR[0] > -20:
+                self.sell()
+            # Williams %R below -80 indicates oversold
+            elif self.williamsr.percR[0] < -80:
+                self.buy()
+"""
+
+import math
+
+from . import DownDay, Highest, Indicator, Lowest, TrueHigh, TrueLow, UpDay
+
+
+class WilliamsR(Indicator):
+    """
+    Developed by Larry Williams to show the relation of closing prices to
+    the highest-lowest range of a given period.
+
+    Known as Williams %R (but % is not allowed in Python identifiers)
+
+    Formula:
+      - num = highest_period - close
+      - den = highestg_period - lowest_period
+      - percR = (num / den) * -100.0
+
+    See:
+      - http://en.wikipedia.org/wiki/Williams_%25R
+    """
+
+    lines = ("percR",)
+    params = (
+        ("period", 14),
+        ("upperband", -20.0),
+        ("lowerband", -80.0),
+    )
+
+    plotinfo = {"plotname": "Williams R%"}
+    plotlines = {"percR": {"_name": "R%"}}
+
+    def _plotinif(self):
+        self.plotinfo.plotyhlines = [self.p.upperband, self.p.lowerband]
+
+    def __init__(self):
+        """Initialize the Williams %R indicator.
+
+        Creates Highest and Lowest indicators for calculation.
+        """
+        super().__init__()
+        self.highest = Highest(self.data.high, period=self.p.period)
+        self.lowest = Lowest(self.data.low, period=self.p.period)
+
+    def next(self):
+        """Calculate Williams %R for the current bar.
+
+        %R = -100 * (highest - close) / (highest - lowest)
+        Returns 0.0 if denominator is 0 to avoid division by zero.
+        """
+        h = self.highest[0]
+        low = self.lowest[0]
+        c = self.data.close[0]
+        den = h - low
+        if den != 0:
+            self.lines.percR[0] = -100.0 * (h - c) / den
+        else:
+            self.lines.percR[0] = 0.0
+
+    def once(self, start, end):
+        """Calculate Williams %R in runonce mode.
+
+        Computes %R values across all bars.
+        """
+        h_array = self.highest.lines[0].array
+        l_array = self.lowest.lines[0].array
+        c_array = self.data.close.array
+        larray = self.lines.percR.array
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        for i in range(start, min(end, len(h_array), len(l_array), len(c_array))):
+            h = h_array[i] if i < len(h_array) else 0.0
+            low = l_array[i] if i < len(l_array) else 0.0
+            c = c_array[i] if i < len(c_array) else 0.0
+
+            if isinstance(h, float) and math.isnan(h) or isinstance(low, float) and math.isnan(low):
+                larray[i] = float("nan")
+            else:
+                den = h - low
+                if den != 0:
+                    larray[i] = -100.0 * (h - c) / den
+                else:
+                    larray[i] = 0.0
+
+
+class WilliamsAD(Indicator):
+    """
+    By Larry Williams. It does cumulatively measure if the price is
+    accumulating (upwards) or distributing (downwards) by using the concept of
+    UpDays and DownDays.
+
+    Prices can go upwards but do so in a fashion that no longer shows
+    accumulation because updays and downdays are canceling out each other,
+    creating a divergence.
+
+    See:
+    - http://www.metastock.com/Customer/Resources/TAAZ/?p=125
+    - http://ta.mql4.com/indicators/trends/williams_accumulation_distribution
+    """
+
+    lines = ("ad",)
+
+    def __init__(self):
+        """Initialize the Williams A/D indicator.
+
+        Creates up/down day and true high/low indicators.
+        """
+        super().__init__()
+        self.upday = UpDay(self.data.close)
+        self.downday = DownDay(self.data.close)
+        self.truelow = TrueLow(self.data)
+        self.truehigh = TrueHigh(self.data)
+        self._accum = 0.0
+
+    def next(self):
+        """Calculate Williams A/D for the current bar.
+
+        Accumulates based on up days and down days using true range.
+        """
+        upday_val = self.upday[0]
+        downday_val = self.downday[0]
+
+        if upday_val > 0:
+            adup = self.data.close[0] - self.truelow[0]
+        else:
+            adup = 0.0
+
+        if downday_val > 0:
+            addown = self.data.close[0] - self.truehigh[0]
+        else:
+            addown = 0.0
+
+        self._accum += adup + addown
+        self.lines.ad[0] = self._accum
+
+    def once(self, start, end):
+        """Calculate Williams A/D in runonce mode.
+
+        Accumulates values across all bars.
+        """
+        upday_array = self.upday.lines[0].array
+        downday_array = self.downday.lines[0].array
+        truelow_array = self.truelow.lines[0].array
+        truehigh_array = self.truehigh.lines[0].array
+        c_array = self.data.close.array
+        larray = self.lines.ad.array
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        accum = 0.0
+        for i in range(start, min(end, len(upday_array), len(downday_array), len(c_array))):
+            upday_val = upday_array[i] if i < len(upday_array) else 0.0
+            downday_val = downday_array[i] if i < len(downday_array) else 0.0
+            close = c_array[i] if i < len(c_array) else 0.0
+            tl = truelow_array[i] if i < len(truelow_array) else 0.0
+            th = truehigh_array[i] if i < len(truehigh_array) else 0.0
+
+            if upday_val > 0:
+                adup = close - tl
+            else:
+                adup = 0.0
+
+            if downday_val > 0:
+                addown = close - th
+            else:
+                addown = 0.0
+
+            accum += adup + addown
+            larray[i] = accum

backtrader/indicators/wma.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+"""WMA Indicator Module - Weighted Moving Average.
+
+This module provides the WMA (Weighted Moving Average) indicator
+which gives more weight to recent prices.
+
+Classes:
+    WeightedMovingAverage: WMA indicator (alias: WMA).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.wma = bt.indicators.WMA(self.data.close, period=20)
+
+        def next(self):
+            # Price above WMA indicates uptrend
+            if self.data.close[0] > self.wma[0]:
+                self.buy()
+            # Price below WMA indicates downtrend
+            elif self.data.close[0] < self.wma[0]:
+                self.sell()
+"""
+
+import math
+
+from ..utils.py3 import range
+from . import MovingAverageBase
+
+
+class WeightedMovingAverage(MovingAverageBase):
+    """
+    A Moving Average which gives an arithmetic weighting to values with the
+    newest having the more weight
+
+    Formula:
+      - weights = range(1, period + 1)
+      - coef = 2 / (period * (period + 1))
+      - movav = coef * Sum(weight[i] * data[period - i] for i in range(period))
+
+    See also:
+      - http://en.wikipedia.org/wiki/Moving_average#Weighted_moving_average
+    """
+
+    alias = (
+        "WMA",
+        "MovingAverageWeighted",
+    )
+    lines = ("wma",)
+
+    def __init__(self):
+        """Initialize the WMA indicator.
+
+        Calculates weights and coefficient for weighted moving average.
+        """
+        super().__init__()
+        self.coef = 2.0 / (self.p.period * (self.p.period + 1.0))
+        self.weights = tuple(float(x) for x in range(1, self.p.period + 1))
+
+    def next(self):
+        """Calculate WMA for the current bar.
+
+        Applies arithmetic weighting with newest values having more weight.
+        Uses math.fsum over chronological (oldest-first) order to match the
+        framework's WeightedAverage accumulation exactly and avoid 1-ULP
+        drift between runonce and event modes.
+        """
+        period = self.p.period
+        coef = self.coef
+        weights = self.weights
+
+        # data oldest-first: data[-(period-1)] .. data[0]
+        data = [self.data[-(period - 1 - i)] for i in range(period)]
+        self.lines.wma[0] = coef * math.fsum(weights[i] * data[i] for i in range(period))
+
+    def once(self, start, end):
+        """Calculate WMA in runonce mode.
+
+        Applies weighted average calculation across all bars. Uses math.fsum
+        over the chronological window (oldest-first) so results match the
+        framework's WeightedAverage and the event-mode next() bit-for-bit.
+        """
+        darray = self.data.array
+        larray = self.lines.wma.array
+        period = self.p.period
+        coef = self.coef
+        weights = self.weights
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        # Pre-fill warmup with NaN
+        for i in range(min(period - 1, len(darray))):
+            if i < len(larray):
+                larray[i] = float("nan")
+
+        darray_len = len(darray)
+        for i in range(period - 1, min(end, darray_len)):
+            window = darray[i - period + 1 : i + 1]
+            # window is oldest-first; weights[0]=1.0 weights the oldest value.
+            larray[i] = coef * math.fsum(weights[j] * window[j] for j in range(period))
+
+
+WMA = WeightedMovingAverage

backtrader/indicators/zlema.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python
+"""ZLEMA Indicator Module - Zero Lag Exponential Moving Average.
+
+This module provides the ZLEMA (Zero Lag Exponential Moving Average)
+indicator which aims to reduce lag in the standard EMA.
+
+Classes:
+    ZeroLagExponentialMovingAverage: ZLEMA indicator (aliases: ZLEMA, ZeroLagEma).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.zlema = bt.indicators.ZLEMA(self.data.close, period=20)
+
+        def next(self):
+            # Price above ZLEMA indicates uptrend
+            if self.data.close[0] > self.zlema[0]:
+                self.buy()
+            # Price below ZLEMA indicates downtrend
+            elif self.data.close[0] < self.zlema[0]:
+                self.sell()
+"""
+
+import math
+
+from . import MovingAverageBase
+from .ema import EMA
+
+
+class ZeroLagExponentialMovingAverage(MovingAverageBase):
+    """
+    The zero-lag exponential moving average (ZLEMA) is a variation of the EMA
+    which adds a momentum term aiming to reduce lag in the average to
+    track current prices more closely.
+
+    Formula:
+      - lag = (period - 1) / 2
+      - zlema = ema(2 * data - data(-lag))
+
+    See also:
+      - http://user42.tuxfamily.org/chart/manual/Zero_002dLag-Exponential-Moving-Average.html
+
+    """
+
+    alias = (
+        "ZLEMA",
+        "ZeroLagEma",
+    )
+    lines = ("zlema",)
+    params = (("_movav", EMA),)
+
+    def __init__(self):
+        """Initialize the ZLEMA indicator.
+
+        Calculates lag and alpha values for zero-lag EMA.
+        """
+        super().__init__()
+        self.lag = (self.p.period - 1) // 2
+        self.alpha = 2.0 / (1.0 + self.p.period)
+        self.alpha1 = 1.0 - self.alpha
+        self.addminperiod(self.lag + self.p.period)
+
+    def nextstart(self):
+        """Seed ZLEMA calculation with SMA on first valid bar.
+
+        Uses SMA of lag-adjusted data for initial seed value.
+        """
+        # Seed with SMA of adjusted data
+        period = self.p.period
+        lag = self.lag
+        data_sum = 0.0
+        for i in range(period):
+            adjusted = 2.0 * self.data[-i] - self.data[-i - lag]
+            data_sum += adjusted
+        self.lines.zlema[0] = data_sum / period
+
+    def next(self):
+        """Calculate ZLEMA for the current bar.
+
+        Applies EMA to lag-adjusted data: 2 * data - data(-lag).
+        """
+        lag = self.lag
+        adjusted = 2.0 * self.data[0] - self.data[-lag]
+        self.lines.zlema[0] = self.lines.zlema[-1] * self.alpha1 + adjusted * self.alpha
+
+    def once(self, start, end):
+        """Calculate ZLEMA in runonce mode.
+
+        Applies EMA to lag-adjusted data across all bars.
+        """
+        darray = self.data.array
+        larray = self.lines.zlema.array
+        period = self.p.period
+        lag = self.lag
+        alpha = self.alpha
+        alpha1 = self.alpha1
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        minperiod = lag + period
+        for i in range(min(minperiod - 1, len(darray))):
+            if i < len(larray):
+                larray[i] = float("nan")
+
+        # Seed value
+        seed_idx = minperiod - 1
+        if seed_idx < len(darray) and seed_idx >= lag:
+            seed_sum = 0.0
+            for j in range(period):
+                idx = seed_idx - j
+                if idx >= lag and idx < len(darray) and idx - lag >= 0:
+                    adjusted = 2.0 * darray[idx] - darray[idx - lag]
+                    seed_sum += adjusted
+            prev = seed_sum / period
+            if seed_idx < len(larray):
+                larray[seed_idx] = prev
+        else:
+            prev = 0.0
+
+        # Calculate ZLEMA
+        for i in range(minperiod, min(end, len(darray))):
+            if i >= lag and i - lag >= 0:
+                adjusted = 2.0 * darray[i] - darray[i - lag]
+            else:
+                adjusted = darray[i]
+
+            if i > 0 and i - 1 < len(larray):
+                prev_val = larray[i - 1]
+                if not (isinstance(prev_val, float) and math.isnan(prev_val)):
+                    prev = prev_val
+
+            prev = prev * alpha1 + adjusted * alpha
+            if i < len(larray):
+                larray[i] = prev

backtrader/indicators/zlind.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+"""Zero Lag Indicator Module - Zero-lag error correction.
+
+This module provides the ZeroLagIndicator developed by John Ehlers
+and Ric Way to reduce lag in moving averages.
+
+Classes:
+    ZeroLagIndicator: Zero-lag indicator with error correction.
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.zlind = bt.indicators.ZeroLagIndicator(self.data.close, period=20, gainlimit=50)
+
+        def next(self):
+            # Price above ZeroLagIndicator indicates uptrend
+            if self.data.close[0] > self.zlind[0]:
+                self.buy()
+            # Price below ZeroLagIndicator indicates downtrend
+            elif self.data.close[0] < self.zlind[0]:
+                self.sell()
+"""
+
+from backtrader.utils.py3 import MAXINT
+
+from . import MovingAverageBase
+from .ema import EMA
+
+
+class ZeroLagIndicator(MovingAverageBase):
+    """By John Ehlers and Ric Way
+
+    The zero-lag indicator (ZLIndicator) is a variation of the EMA
+    which modifies the EMA by trying to minimize the error (distance price -
+    error correction) and thus reduce the lag
+
+    Formula:
+      - EMA(data, period)
+
+      - For each iteration calculate a best-error-correction of the ema (see
+        the paper and/or the code) iterating over ``-bestgain`` ->
+        ``+bestgain`` for the error correction factor (both incl.)
+
+      - The default moving average 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`` in the instance
+
+    See also:
+      - http://www.mesasoftware.com/papers/ZeroLag.pdf
+
+    """
+
+    alias = (
+        "ZLIndicator",
+        "ZLInd",
+        "EC",
+        "ErrorCorrecting",
+    )
+    lines = ("ec",)
+    params = (
+        ("gainlimit", 50),
+        ("_movav", EMA),
+    )
+
+    def _plotlabel(self):
+        plabels = [self.p.period, self.p.gainlimit]
+        plabels += [self.p._movav] * self.p.notdefault("_movav")
+        return plabels
+
+    def __init__(self):
+        """Initialize the Zero Lag Indicator.
+
+        Creates EMA and sets up gain limits for error correction.
+        """
+        self.ema = self.p._movav(period=self.p.period)
+        self.limits = [-self.p.gainlimit, self.p.gainlimit + 1]
+
+        # To make mixins work - super at the end for cooperative inheritance
+        super().__init__()
+
+    def next(self):
+        """Calculate zero lag indicator for the current bar.
+
+        Iterates over gain values to find the error correction that
+        minimizes the difference between price and corrected EMA.
+        """
+        leasterror = MAXINT  # 1000000 in original code
+        bestec = ema = self.ema[0]  # seed value 1st time for ec
+        price = self.data[0]
+        ec1 = self.lines.ec[-1]
+        alpha, alpha1 = self.ema.alpha, self.ema.alpha1
+
+        for value1 in range(*self.limits):
+            gain = value1 / 10
+            ec = alpha * (ema + gain * (price - ec1)) + alpha1 * ec1
+            error = abs(price - ec)
+            if error < leasterror:
+                leasterror = error
+                bestec = ec
+
+        self.lines.ec[0] = bestec