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

backtrader/indicators/trix.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python
+"""TRIX Indicator Module - Triple exponential moving average slope.
+
+This module provides the TRIX indicator developed by Jack Hutson in the
+1980s to show the rate of change of a triple smoothed moving average.
+
+Classes:
+    Trix: TRIX indicator (alias: TRIX).
+    TrixSignal: TRIX with signal line.
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.trix = bt.indicators.TRIX(self.data.close, period=15)
+
+        def next(self):
+            if self.trix[0] > 0:
+                self.buy()
+"""
+
+import math
+
+from . import Indicator
+from .ema import EMA
+
+
+class Trix(Indicator):
+    """
+    Defined by Jack Hutson in the 80s and shows the Rate of Change (%) or slope
+    of a triple exponentially smoothed moving average
+
+    Formula:
+      - ema1 = EMA(data, period)
+      - ema2 = EMA(ema1, period)
+      - ema3 = EMA(ema2, period)
+      - trix = 100 * (ema3 - ema3(-1)) / ema3(-1)
+
+      The final formula can be simplified to: 100 * (ema3 / ema3(-1) - 1)
+
+    The moving average used is the one originally defined by Wilder,
+    the SmoothedMovingAverage
+
+    See:
+      - https://en.wikipedia.org/wiki/Trix_(technical_analysis)
+      - http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:trix
+    """
+
+    alias = ("TRIX",)
+    lines = ("trix",)
+    params = (
+        ("period", 15),
+        ("_rocperiod", 1),
+        ("_movav", EMA),
+    )
+
+    plotinfo = {"plothlines": [0.0]}
+
+    def _plotlabel(self):
+        plabels = [self.p.period]
+        plabels += [self.p._rocperiod] * self.p.notdefault("_rocperiod")
+        plabels += [self.p._movav] * self.p.notdefault("_movav")
+        return plabels
+
+    def __init__(self):
+        """Initialize the TRIX indicator.
+
+        Creates triple EMA structure for TRIX calculation.
+        """
+        super().__init__()
+        self.ema1 = self.p._movav(self.data, period=self.p.period)
+        self.ema2 = self.p._movav(self.ema1, period=self.p.period)
+        self.ema3 = self.p._movav(self.ema2, period=self.p.period)
+        # minperiod = 3 * period + rocperiod
+        self._minperiod = max(self._minperiod, 3 * self.p.period + self.p._rocperiod - 2)
+
+    def next(self):
+        """Calculate TRIX for the current bar.
+
+        Formula: TRIX = 100 * (ema3 / ema3_rocperiod_ago - 1.0)
+        """
+        rocperiod = self.p._rocperiod
+        ema3_curr = self.ema3[0]
+        ema3_prev = self.ema3[-rocperiod]
+        if ema3_prev != 0:
+            self.lines.trix[0] = 100.0 * (ema3_curr / ema3_prev - 1.0)
+        else:
+            self.lines.trix[0] = 0.0
+
+    def once(self, start, end):
+        """Calculate TRIX in runonce mode.
+
+        Computes triple EMA rate of change percentage across all bars.
+        """
+        ema3_array = self.ema3.lines[0].array
+        larray = self.lines.trix.array
+        rocperiod = self.p._rocperiod
+        minperiod = 3 * self.p.period + rocperiod - 2
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        for i in range(min(minperiod, len(ema3_array))):
+            if i < len(larray):
+                larray[i] = float("nan")
+
+        for i in range(minperiod, min(end, len(ema3_array))):
+            ema3_curr = ema3_array[i] if i < len(ema3_array) else 0.0
+            ema3_prev = (
+                ema3_array[i - rocperiod]
+                if i >= rocperiod and i - rocperiod < len(ema3_array)
+                else 0.0
+            )
+
+            if (
+                isinstance(ema3_curr, float)
+                and math.isnan(ema3_curr)
+                or isinstance(ema3_prev, float)
+                and math.isnan(ema3_prev)
+            ):
+                larray[i] = float("nan")
+            elif ema3_prev != 0:
+                larray[i] = 100.0 * (ema3_curr / ema3_prev - 1.0)
+            else:
+                larray[i] = 0.0
+
+
+class TrixSignal(Trix):
+    """
+    Extension of Trix with a signal line (ala MACD)
+
+    Formula:
+      - trix = Trix(data, period)
+      - signal = EMA(trix, sigperiod)
+
+    See:
+      - http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:trix
+    """
+
+    lines = ("signal",)
+    params = (("sigperiod", 9),)
+
+    def __init__(self):
+        """Initialize the TRIX Signal indicator.
+
+        Sets up signal line EMA smoothing parameters.
+        """
+        super().__init__()
+        self.signal_alpha = 2.0 / (1.0 + self.p.sigperiod)
+        self.signal_alpha1 = 1.0 - self.signal_alpha
+
+    def nextstart(self):
+        """Seed TRIX Signal calculation on first valid bar.
+
+        Initializes signal line with TRIX value.
+        """
+        super().next()
+        self.lines.signal[0] = self.lines.trix[0]
+
+    def next(self):
+        """Calculate TRIX and signal line for current bar.
+
+        Signal line is EMA of TRIX values.
+        """
+        super().next()
+        self.lines.signal[0] = (
+            self.lines.signal[-1] * self.signal_alpha1 + self.lines.trix[0] * self.signal_alpha
+        )
+
+    def once(self, start, end):
+        """Calculate TRIX Signal in runonce mode.
+
+        Computes signal line as EMA of TRIX values across all bars.
+        """
+        super().once(start, end)
+        trix_array = self.lines.trix.array
+        signal_array = self.lines.signal.array
+        signal_alpha = self.signal_alpha
+        signal_alpha1 = self.signal_alpha1
+
+        while len(signal_array) < end:
+            signal_array.append(float("nan"))
+
+        # Find first valid trix value for seed
+        seed_idx = -1
+        for i in range(len(trix_array)):
+            if i < len(trix_array):
+                val = trix_array[i]
+                if not (isinstance(val, float) and math.isnan(val)):
+                    seed_idx = i
+                    break
+
+        if seed_idx >= 0 and seed_idx < len(signal_array):
+            prev_signal = trix_array[seed_idx]
+            signal_array[seed_idx] = prev_signal
+
+            for i in range(seed_idx + 1, min(end, len(trix_array))):
+                trix_val = trix_array[i] if i < len(trix_array) else 0.0
+                if isinstance(trix_val, float) and math.isnan(trix_val):
+                    signal_array[i] = float("nan")
+                else:
+                    prev_signal = prev_signal * signal_alpha1 + trix_val * signal_alpha
+                    signal_array[i] = prev_signal

backtrader/indicators/tsi.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python
+"""TSI Indicator Module - True Strength Index.
+
+This module provides the TSI (True Strength Index) indicator developed
+by William Blau for measuring momentum with double smoothing.
+
+Classes:
+    TrueStrengthIndicator: TSI indicator (alias: TSI).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.tsi = bt.indicators.TSI(self.data.close, period1=25, period2=13)
+
+        def next(self):
+            if self.tsi[0] > 0:
+                self.buy()
+"""
+
+from . import Indicator
+from .ema import ExponentialMovingAverage
+
+
+class TrueStrengthIndicator(Indicator):
+    """
+    The True Strength Indicators was first introduced in Stocks & Commodities
+    Magazine by its author William Blau. It measures momentum with a double
+    exponential (default) of the prices.
+
+    It shows divergence if the extremes keep on growign but closing prices
+    do not in the same manner (distance to the extremes grows)
+
+    Formula:
+      - price_change = close - close(pchange periods ago)
+      - sm1_simple = EMA(price_close_change, period1)
+      - sm1_double = EMA(sm1_simple, period2)
+      - sm2_simple = EMA(abs(price_close_change), period1)
+      - sm2_double = EMA(sm2_simple, period2)
+      - tsi = 100.0 * sm1_double / sm2_double
+
+    See:
+      - http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:true_strength_index
+
+    Params
+
+      - ``period1``: the period for the first smoothing
+      - ``period2``: the period for the second smoothing
+      - ``pchange``: the lookback period for the price change
+      - ``_movav``: the moving average to apply for the smoothing
+    """
+
+    alias = ("TSI",)
+    params = (
+        ("period1", 25),
+        ("period2", 13),
+        ("pchange", 1),
+        ("_movav", ExponentialMovingAverage),
+    )
+    lines = ("tsi",)
+
+    def __init__(self):
+        """Initialize the TSI indicator.
+
+        Calculates alpha values for double smoothing and sets
+        minimum period based on pchange + period1 + period2.
+        """
+        super().__init__()
+        # Store sub-indicators for direct calculation
+        self.alpha1 = 2.0 / (1.0 + self.p.period1)
+        self.alpha1_1 = 1.0 - self.alpha1
+        self.alpha2 = 2.0 / (1.0 + self.p.period2)
+        self.alpha2_1 = 1.0 - self.alpha2
+
+        self._sm1 = 0.0
+        self._sm12 = 0.0
+        self._sm2 = 0.0
+        self._sm22 = 0.0
+
+        self.addminperiod(self.p.pchange + self.p.period1 + self.p.period2)
+
+    def nextstart(self):
+        """Seed TSI calculation on first valid bar.
+
+        Initializes smoothed momentum values with first price change.
+        """
+        pc = self.data[0] - self.data[-self.p.pchange]
+        self._sm1 = pc
+        self._sm12 = pc
+        self._sm2 = abs(pc)
+        self._sm22 = abs(pc)
+
+        if self._sm22 != 0:
+            self.lines.tsi[0] = 100.0 * self._sm12 / self._sm22
+        else:
+            self.lines.tsi[0] = 0.0
+
+    def next(self):
+        """Calculate TSI for the current bar.
+
+        Applies double smoothing to price change and absolute price change,
+        then computes the ratio as a percentage.
+        """
+        pc = self.data[0] - self.data[-self.p.pchange]
+
+        self._sm1 = self._sm1 * self.alpha1_1 + pc * self.alpha1
+        self._sm12 = self._sm12 * self.alpha2_1 + self._sm1 * self.alpha2
+
+        self._sm2 = self._sm2 * self.alpha1_1 + abs(pc) * self.alpha1
+        self._sm22 = self._sm22 * self.alpha2_1 + self._sm2 * self.alpha2
+
+        if self._sm22 != 0:
+            self.lines.tsi[0] = 100.0 * self._sm12 / self._sm22
+        else:
+            self.lines.tsi[0] = 0.0
+
+    def once(self, start, end):
+        """Calculate TSI in runonce mode.
+
+        Computes double-smoothed momentum values and TSI ratio
+        across all bars.
+        """
+        darray = self.data.array
+        larray = self.lines.tsi.array
+        pchange = self.p.pchange
+        alpha1 = self.alpha1
+        alpha1_1 = self.alpha1_1
+        alpha2 = self.alpha2
+        alpha2_1 = self.alpha2_1
+        minperiod = pchange + self.p.period1 + self.p.period2
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        for i in range(min(minperiod - 1, len(darray))):
+            if i < len(larray):
+                larray[i] = float("nan")
+
+        sm1 = 0.0
+        sm12 = 0.0
+        sm2 = 0.0
+        sm22 = 0.0
+
+        for i in range(pchange, min(end, len(darray))):
+            pc = darray[i] - darray[i - pchange]
+
+            sm1 = sm1 * alpha1_1 + pc * alpha1
+            sm12 = sm12 * alpha2_1 + sm1 * alpha2
+            sm2 = sm2 * alpha1_1 + abs(pc) * alpha1
+            sm22 = sm22 * alpha2_1 + sm2 * alpha2
+
+            if i >= minperiod - 1:
+                if sm22 != 0:
+                    larray[i] = 100.0 * sm12 / sm22
+                else:
+                    larray[i] = 0.0

backtrader/indicators/ultimateoscillator.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python
+"""Ultimate Oscillator Module - Ultimate Oscillator indicator.
+
+This module provides the Ultimate Oscillator indicator which combines
+multiple timeframes to reduce false signals.
+
+Classes:
+    UltimateOscillator: Ultimate Oscillator indicator.
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.uo = bt.indicators.UltimateOscillator(self.data)
+
+        def next(self):
+            if self.uo[0] > 70:
+                self.sell()
+"""
+
+from . import Indicator, TrueLow, TrueRange
+
+
+class UltimateOscillator(Indicator):
+    """
+    Formula:
+      # Buying Pressure = Close - TrueLow
+      BP = Close - Minimum (Low or Prior Close)
+
+      # TrueRange = TrueHigh - TrueLow
+      TR = Maximum (High or Prior Close) - Minimum (Low or Prior Close)
+
+      Average7 = (7-period BP Sum) / (7-period TR Sum)
+      Average14 = (14-period BP Sum) / (14-period TR Sum)
+      Average28 = (28-period BP Sum) / (28-period TR Sum)
+
+      UO = 100 x [(4 x Average7)+(2 x Average14)+Average28]/(4+2+1)
+
+    See:
+
+      - https://en.wikipedia.org/wiki/Ultimate_oscillator
+      - http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:ultimate_oscillator
+    """
+
+    lines = ("uo",)
+
+    params = (
+        ("p1", 7),
+        ("p2", 14),
+        ("p3", 28),
+        ("upperband", 70.0),
+        ("lowerband", 30.0),
+    )
+
+    def _plotinit(self):
+        baseticks = [10.0, 50.0, 90.0]
+        hlines = [self.p.upperband, self.p.lowerband]
+
+        # Plot lines at 0 & 100 to make the scale complete + upper/lower/bands
+        self.plotinfo.plotyhlines = hlines
+        # Plot ticks at "baseticks" + the user specified upper/lower bands
+        self.plotinfo.plotyticks = baseticks + hlines
+
+    def __init__(self):
+        """Initialize the Ultimate Oscillator indicator.
+
+        Creates TrueLow and TrueRange indicators for BP/TR calculations.
+        """
+        super().__init__()
+        self.truelow = TrueLow(self.data)
+        self.truerange = TrueRange(self.data)
+        # TrueRange/TrueLow already contribute minperiod=2 (they need close[-1]).
+        # We need a total minperiod of p3 + 1 because we read close[-i]/truelow[-i]/
+        # truerange[-i] for i in [0, p3-1], so we need p3 historical bars plus the
+        # current one. addminperiod(p3 + 1) accumulates correctly under the new
+        # max-path semantics in LineMultiple.addminperiod.
+        self.addminperiod(self.p.p3 + 1)
+
+    def next(self):
+        """Calculate Ultimate Oscillator for the current bar.
+
+        Combines 3 timeframes (p1, p2, p3) to reduce false signals.
+        """
+        p1, p2, p3 = self.p.p1, self.p.p2, self.p.p3
+
+        # Calculate BP and TR sums for each period
+        bp_sum1 = tr_sum1 = 0.0
+        bp_sum2 = tr_sum2 = 0.0
+        bp_sum3 = tr_sum3 = 0.0
+
+        for i in range(p3):
+            bp = self.data.close[-i] - self.truelow[-i]
+            tr = self.truerange[-i]
+
+            if i < p1:
+                bp_sum1 += bp
+                tr_sum1 += tr
+            if i < p2:
+                bp_sum2 += bp
+                tr_sum2 += tr
+            bp_sum3 += bp
+            tr_sum3 += tr
+
+        av7 = bp_sum1 / tr_sum1 if tr_sum1 != 0 else 0.0
+        av14 = bp_sum2 / tr_sum2 if tr_sum2 != 0 else 0.0
+        av28 = bp_sum3 / tr_sum3 if tr_sum3 != 0 else 0.0
+
+        factor = 100.0 / 7.0
+        self.lines.uo[0] = (4.0 * factor) * av7 + (2.0 * factor) * av14 + factor * av28
+
+    def once(self, start, end):
+        """Calculate Ultimate Oscillator in runonce mode.
+
+        Combines BP/TR sums across 3 timeframes for all bars.
+        """
+        close_array = self.data.close.array
+        tl_array = self.truelow.lines[0].array
+        tr_array = self.truerange.lines[0].array
+        larray = self.lines.uo.array
+        p1, p2, p3 = self.p.p1, self.p.p2, self.p.p3
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        for i in range(min(p3 - 1, len(close_array))):
+            if i < len(larray):
+                larray[i] = float("nan")
+
+        for i in range(p3 - 1, min(end, len(close_array), len(tl_array), len(tr_array))):
+            bp_sum1 = tr_sum1 = 0.0
+            bp_sum2 = tr_sum2 = 0.0
+            bp_sum3 = tr_sum3 = 0.0
+
+            for j in range(p3):
+                idx = i - j
+                if (
+                    idx >= 0
+                    and idx < len(close_array)
+                    and idx < len(tl_array)
+                    and idx < len(tr_array)
+                ):
+                    bp = close_array[idx] - tl_array[idx]
+                    tr = tr_array[idx]
+
+                    if j < p1:
+                        bp_sum1 += bp
+                        tr_sum1 += tr
+                    if j < p2:
+                        bp_sum2 += bp
+                        tr_sum2 += tr
+                    bp_sum3 += bp
+                    tr_sum3 += tr
+
+            av7 = bp_sum1 / tr_sum1 if tr_sum1 != 0 else 0.0
+            av14 = bp_sum2 / tr_sum2 if tr_sum2 != 0 else 0.0
+            av28 = bp_sum3 / tr_sum3 if tr_sum3 != 0 else 0.0
+
+            factor = 100.0 / 7.0
+            larray[i] = (4.0 * factor) * av7 + (2.0 * factor) * av14 + factor * av28

backtrader/indicators/vortex.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+"""Vortex Indicator Module - Vortex trend indicator.
+
+This module provides the Vortex indicator for identifying trend
+direction and strength.
+
+Classes:
+    Vortex: Vortex indicator with VI+ and VI- lines.
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.vortex = bt.indicators.Vortex(self.data, period=14)
+
+        def next(self):
+            # VI+ crossing above VI- indicates uptrend
+            if self.vortex.vi_plus[0] > self.vortex.vi_minus[0]:
+                self.buy()
+            # VI- crossing above VI+ indicates downtrend
+            elif self.vortex.vi_minus[0] > self.vortex.vi_plus[0]:
+                self.sell()
+"""
+
+from . import Indicator, Max, SumN
+
+
+class Vortex(Indicator):
+    """
+    See:
+      - http://www.vortexindicator.com/VFX_VORTEX.PDF
+
+    """
+
+    lines = (
+        "vi_plus",
+        "vi_minus",
+    )
+
+    params = (("period", 14),)
+
+    plotlines = {"vi_plus": {"_name": "+VI"}, "vi_minus": {"_name": "-VI"}}
+
+    def __init__(self):
+        """Initialize the Vortex indicator.
+
+        Sets up VI+ and VI- calculations based on True Range and
+        directional movement.
+        """
+        h0l1 = abs(self.data.high(0) - self.data.low(-1))
+        vm_plus = SumN(h0l1, period=self.p.period)
+
+        l0h1 = abs(self.data.low(0) - self.data.high(-1))
+        vm_minus = SumN(l0h1, period=self.p.period)
+
+        h0c1 = abs(self.data.high(0) - self.data.close(-1))
+        l0c1 = abs(self.data.low(0) - self.data.close(-1))
+        h0l0 = abs(self.data.high(0) - self.data.low(0))
+
+        tr = SumN(Max(h0l0, h0c1, l0c1), period=self.p.period)
+
+        self.l.vi_plus = vm_plus / tr
+        self.l.vi_minus = vm_minus / tr