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

backtrader/indicators/ichimoku.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python
+"""Ichimoku Indicator Module - Ichimoku Cloud.
+
+This module provides the Ichimoku Kinko Hyo (Ichimoku Cloud) indicator
+developed by Goichi Hosoda in 1969 for comprehensive trend analysis.
+
+Classes:
+    Ichimoku: Ichimoku Cloud indicator with multiple lines.
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.ichimoku = bt.indicators.Ichimoku(self.data)
+
+        def next(self):
+            # Price above cloud indicates uptrend
+            if (self.data.close[0] > self.ichimoku.senkou_span_a[0] and
+                self.data.close[0] > self.ichimoku.senkou_span_b[0]):
+                self.buy()
+"""
+
+import math
+
+from . import Highest, Indicator, Lowest
+
+
+def _line_value(line, ago=0):
+    try:
+        return line[ago]
+    except (IndexError, TypeError):
+        return float("nan")
+
+
+def _valid(value):
+    return value is not None and not (isinstance(value, float) and not math.isfinite(value))
+
+
+class Ichimoku(Indicator):
+    """
+    Developed and published in his book in 1969 by journalist Goichi Hosoda
+
+    Formula:
+      - tenkan_sen = (Highest (High, tenkan) + Lowest (Low, tenkan)) / 2.0
+      - kijun_sen = (Highest (High, kijun) + Lowest (Low, kijun)) / 2.0
+
+      The next 2 are pushed 26 bars into the future
+
+      - senkou_span_a = (tenkan_sen + kijun_sen) / 2.0
+      - senkou_span_b = ((Highest (High, senkou) + Lowest (Low, senkou)) / 2.0
+
+      This is pushed 26 bars into the past
+
+      - chikou = close
+
+    The cloud (Kumo) is formed by the area between the senkou_spans
+
+    See:
+      - http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:ichimoku_cloud
+
+    """
+
+    lines = (
+        "tenkan_sen",
+        "kijun_sen",
+        "senkou_span_a",
+        "senkou_span_b",
+        "chikou_span",
+    )
+    params = (
+        ("tenkan", 9),
+        ("kijun", 26),
+        ("senkou", 52),
+        ("senkou_lead", 26),  # forward push
+        ("chikou", 26),  # backwards push
+    )
+
+    plotinfo = {"subplot": False}
+    plotlines = {
+        "senkou_span_a": {"_fill_gt": ("senkou_span_b", "g"), "_fill_lt": ("senkou_span_b", "r")},
+    }
+
+    def __init__(self):
+        """Initialize the Ichimoku Cloud indicator.
+
+        Creates Highest and Lowest sub-indicators for calculating
+        the five Ichimoku lines: tenkan_sen, kijun_sen, senkou_span_a,
+        senkou_span_b, and chikou_span.
+        """
+        super().__init__()
+
+        # Create sub-indicators and store references for explicit computation
+        self.hi_tenkan = Highest(self.data.high, period=self.p.tenkan)
+        self.lo_tenkan = Lowest(self.data.low, period=self.p.tenkan)
+
+        self.hi_kijun = Highest(self.data.high, period=self.p.kijun)
+        self.lo_kijun = Lowest(self.data.low, period=self.p.kijun)
+
+        self.hi_senkou = Highest(self.data.high, period=self.p.senkou)
+        self.lo_senkou = Lowest(self.data.low, period=self.p.senkou)
+
+        # Calculate minperiod - need senkou_lead bars of history for the forward shift
+        self._minperiod = max(self._minperiod, self.p.senkou + self.p.senkou_lead)
+
+        # Propagate minperiod to lines
+        for line in self.lines:
+            line.updateminperiod(self._minperiod)
+
+    def next(self):
+        """Calculate Ichimoku values for the current bar."""
+        # Calculate tenkan_sen and kijun_sen
+        hi_tenkan_val = _line_value(self.hi_tenkan)
+        lo_tenkan_val = _line_value(self.lo_tenkan)
+        tenkan_val = (
+            (hi_tenkan_val + lo_tenkan_val) / 2.0
+            if _valid(hi_tenkan_val) and _valid(lo_tenkan_val)
+            else float("nan")
+        )
+        self.lines.tenkan_sen[0] = tenkan_val
+
+        hi_kijun_val = _line_value(self.hi_kijun)
+        lo_kijun_val = _line_value(self.lo_kijun)
+        kijun_val = (
+            (hi_kijun_val + lo_kijun_val) / 2.0
+            if _valid(hi_kijun_val) and _valid(lo_kijun_val)
+            else float("nan")
+        )
+        self.lines.kijun_sen[0] = kijun_val
+
+        # senkou_span_a: (tenkan + kijun) / 2, shifted forward by senkou_lead
+        # At current bar, we display the value calculated senkou_lead bars ago
+        shift = self.p.senkou_lead
+        if len(self) > shift:
+            past_hi_tenkan = _line_value(self.hi_tenkan, -shift)
+            past_lo_tenkan = _line_value(self.lo_tenkan, -shift)
+            past_hi_kijun = _line_value(self.hi_kijun, -shift)
+            past_lo_kijun = _line_value(self.lo_kijun, -shift)
+            if all(
+                _valid(v) for v in (past_hi_tenkan, past_lo_tenkan, past_hi_kijun, past_lo_kijun)
+            ):
+                past_tenkan = (past_hi_tenkan + past_lo_tenkan) / 2.0
+                past_kijun = (past_hi_kijun + past_lo_kijun) / 2.0
+                self.lines.senkou_span_a[0] = (past_tenkan + past_kijun) / 2.0
+            else:
+                self.lines.senkou_span_a[0] = float("nan")
+        else:
+            self.lines.senkou_span_a[0] = float("nan")
+
+        # senkou_span_b: (hi_senkou + lo_senkou) / 2, shifted forward by senkou_lead
+        if len(self) > shift:
+            past_hi_senkou = _line_value(self.hi_senkou, -shift)
+            past_lo_senkou = _line_value(self.lo_senkou, -shift)
+            if _valid(past_hi_senkou) and _valid(past_lo_senkou):
+                self.lines.senkou_span_b[0] = (past_hi_senkou + past_lo_senkou) / 2.0
+            else:
+                self.lines.senkou_span_b[0] = float("nan")
+        else:
+            self.lines.senkou_span_b[0] = float("nan")
+
+        # chikou_span: close shifted backward (displayed chikou bars in the past)
+        # When accessing chikou_span[0], we get current close (it will be plotted chikou bars back)
+        self.lines.chikou_span[0] = self.data.close[0]
+
+    def once(self, start, end):
+        """Calculate Ichimoku in runonce mode"""
+        # Get arrays from sub-indicators
+        hi_tenkan_arr = self.hi_tenkan.lines[0].array
+        lo_tenkan_arr = self.lo_tenkan.lines[0].array
+        hi_kijun_arr = self.hi_kijun.lines[0].array
+        lo_kijun_arr = self.lo_kijun.lines[0].array
+        hi_senkou_arr = self.hi_senkou.lines[0].array
+        lo_senkou_arr = self.lo_senkou.lines[0].array
+        close_arr = self.data.close.array
+
+        # Get output arrays
+        tenkan_arr = self.lines.tenkan_sen.array
+        kijun_arr = self.lines.kijun_sen.array
+        senkou_a_arr = self.lines.senkou_span_a.array
+        senkou_b_arr = self.lines.senkou_span_b.array
+        chikou_arr = self.lines.chikou_span.array
+
+        # Ensure output arrays are sized
+        for arr in [tenkan_arr, kijun_arr, senkou_a_arr, senkou_b_arr, chikou_arr]:
+            while len(arr) < end:
+                arr.append(float("nan"))
+
+        shift = self.p.senkou_lead
+
+        for i in range(start, min(end, len(hi_tenkan_arr), len(lo_tenkan_arr))):
+            # tenkan_sen
+            hi_t = hi_tenkan_arr[i]
+            lo_t = lo_tenkan_arr[i]
+            if hi_t is not None and lo_t is not None:
+                if not (isinstance(hi_t, float) and math.isnan(hi_t)) and not (
+                    isinstance(lo_t, float) and math.isnan(lo_t)
+                ):
+                    tenkan_arr[i] = (hi_t + lo_t) / 2.0
+                else:
+                    tenkan_arr[i] = float("nan")
+            else:
+                tenkan_arr[i] = float("nan")
+
+            # kijun_sen
+            if i < len(hi_kijun_arr) and i < len(lo_kijun_arr):
+                hi_k = hi_kijun_arr[i]
+                lo_k = lo_kijun_arr[i]
+                if hi_k is not None and lo_k is not None:
+                    if not (isinstance(hi_k, float) and math.isnan(hi_k)) and not (
+                        isinstance(lo_k, float) and math.isnan(lo_k)
+                    ):
+                        kijun_arr[i] = (hi_k + lo_k) / 2.0
+                    else:
+                        kijun_arr[i] = float("nan")
+                else:
+                    kijun_arr[i] = float("nan")
+
+            # senkou_span_a: shifted forward by senkou_lead
+            # Value at index i is calculated from index (i - shift)
+            past_idx = i - shift
+            if (
+                past_idx >= 0
+                and past_idx < len(hi_tenkan_arr)
+                and past_idx < len(lo_tenkan_arr)
+                and past_idx < len(hi_kijun_arr)
+                and past_idx < len(lo_kijun_arr)
+            ):
+                past_hi_t = hi_tenkan_arr[past_idx]
+                past_lo_t = lo_tenkan_arr[past_idx]
+                past_hi_k = hi_kijun_arr[past_idx]
+                past_lo_k = lo_kijun_arr[past_idx]
+
+                valid = True
+                for v in [past_hi_t, past_lo_t, past_hi_k, past_lo_k]:
+                    if v is None or (isinstance(v, float) and math.isnan(v)):
+                        valid = False
+                        break
+
+                if valid:
+                    past_tenkan = (past_hi_t + past_lo_t) / 2.0
+                    past_kijun = (past_hi_k + past_lo_k) / 2.0
+                    senkou_a_arr[i] = (past_tenkan + past_kijun) / 2.0
+                else:
+                    senkou_a_arr[i] = float("nan")
+            else:
+                senkou_a_arr[i] = float("nan")
+
+            # senkou_span_b: shifted forward by senkou_lead
+            if past_idx >= 0 and past_idx < len(hi_senkou_arr) and past_idx < len(lo_senkou_arr):
+                past_hi_s = hi_senkou_arr[past_idx]
+                past_lo_s = lo_senkou_arr[past_idx]
+
+                if past_hi_s is not None and past_lo_s is not None:
+                    if not (isinstance(past_hi_s, float) and math.isnan(past_hi_s)) and not (
+                        isinstance(past_lo_s, float) and math.isnan(past_lo_s)
+                    ):
+                        senkou_b_arr[i] = (past_hi_s + past_lo_s) / 2.0
+                    else:
+                        senkou_b_arr[i] = float("nan")
+                else:
+                    senkou_b_arr[i] = float("nan")
+            else:
+                senkou_b_arr[i] = float("nan")
+
+            # chikou_span: current close (will be plotted shifted back)
+            if i < len(close_arr):
+                chikou_arr[i] = close_arr[i]
+            else:
+                chikou_arr[i] = float("nan")

backtrader/indicators/kama.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python
+"""KAMA Indicator Module - Kaufman's Adaptive Moving Average.
+
+This module provides the KAMA (Kaufman's Adaptive Moving Average) indicator
+developed by Perry Kaufman to adapt to market volatility and direction.
+
+Classes:
+    AdaptiveMovingAverage: KAMA indicator (aliases: KAMA, MovingAverageAdaptive).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.kama = bt.indicators.KAMA(self.data.close, period=30, fast=2, slow=30)
+
+        def next(self):
+            if self.data.close[0] > self.kama[0]:
+                self.buy()
+"""
+
+import math
+
+from . import MovingAverageBase
+
+
+class AdaptiveMovingAverage(MovingAverageBase):
+    """
+    Defined by Perry Kaufman in his book `"Smarter Trading"`.
+
+    It is A Moving Average with a continuously scaled smoothing factor by
+    taking into account market direction and volatility. The smoothing factor
+    is calculated from 2 ExponetialMovingAverage smoothing factors, a fast one
+    and slow one.
+
+    If the market trends, the value will tend to the fast ema smoothing
+    period. If the market doesn't trend, it will move towards the slow EMA
+    smoothing period.
+
+    It is a subclass of SmoothingMovingAverage, overriding once to account for
+    the live nature of the smoothing factor
+
+    Formula:
+      - direction = close - close_period
+      - volatility = sumN(abs (close - close_n), period)
+      - effiency_ratio = abs (direction / volatility)
+      - fast = 2 / (fast_period + 1)
+      - slow = 2 / (slow_period + 1)
+
+      - Smfactor = squared(efficienty_ratio * (fast - slow) + slow)
+      - smfactor1 = 1.0 - smfactor
+
+      - The initial seed value is a SimpleMovingAverage
+
+    See also:
+      - http://fxcodebase.com/wiki/index.php/Kaufman's_Adaptive_Moving_Average_(KAMA)
+      - http://www.metatrader5.com/en/terminal/help/analytics/indicators/trend_indicators/ama
+      - http://help.cqg.com/cqgic/default.htm#!Documents/adaptivemovingaverag2.htm
+    """
+
+    alias = (
+        "KAMA",
+        "MovingAverageAdaptive",
+    )
+    lines = ("kama",)
+    params = (("fast", 2), ("slow", 30))
+
+    def __init__(self):
+        """Initialize the KAMA indicator.
+
+        Calculates fast and slow smoothing constants for the
+        adaptive moving average.
+        """
+        super().__init__()
+        self.fast_sc = 2.0 / (self.p.fast + 1.0)
+        self.slow_sc = 2.0 / (self.p.slow + 1.0)
+
+    def _calc_sc(self):
+        """Calculate smoothing constant based on efficiency ratio"""
+        period = self.p.period
+
+        # direction = close - close_period
+        direction = self.data[0] - self.data[-period]
+
+        # volatility = sum of abs(close - close_prev) over period
+        volatility = 0.0
+        for i in range(period):
+            volatility += abs(self.data[-i] - self.data[-i - 1])
+
+        # efficiency ratio
+        if volatility != 0:
+            er = abs(direction / volatility)
+        else:
+            er = 0.0
+
+        # smoothing constant = (er * (fast - slow) + slow)^2
+        sc = pow(er * (self.fast_sc - self.slow_sc) + self.slow_sc, 2)
+        return sc
+
+    def nextstart(self):
+        """Seed KAMA calculation with SMA on first valid bar.
+
+        Calculates simple moving average for the initial seed value.
+        """
+        # Seed with SMA
+        period = self.p.period
+        data_sum = 0.0
+        for i in range(period):
+            data_sum += self.data[-i]
+        self.lines.kama[0] = data_sum / period
+
+    def next(self):
+        """Calculate KAMA for the current bar.
+
+        KAMA = prev_KAMA + sc * (price - prev_KAMA)
+        where sc is the adaptive smoothing constant.
+        """
+        sc = self._calc_sc()
+        self.lines.kama[0] = self.lines.kama[-1] + sc * (self.data[0] - self.lines.kama[-1])
+
+    def once(self, start, end):
+        """Calculate KAMA in runonce mode.
+
+        Seeds with SMA and applies adaptive smoothing for each bar.
+        """
+        darray = self.data.array
+        larray = self.lines.kama.array
+        period = self.p.period
+        fast_sc = self.fast_sc
+        slow_sc = self.slow_sc
+
+        while len(larray) < end:
+            larray.append(float("nan"))
+
+        # Pre-fill warmup with NaN
+        for i in range(min(period, len(darray))):
+            if i < len(larray):
+                larray[i] = float("nan")
+
+        # Calculate seed value (SMA)
+        seed_idx = period
+        if seed_idx < len(darray):
+            seed_sum = sum(darray[seed_idx - period : seed_idx])
+            prev_kama = seed_sum / period
+            if seed_idx < len(larray):
+                larray[seed_idx] = prev_kama
+        else:
+            prev_kama = 0.0
+
+        # Calculate KAMA
+        for i in range(seed_idx + 1, min(end, len(darray))):
+            # direction
+            if i >= period and i - period >= 0:
+                direction = darray[i] - darray[i - period]
+            else:
+                direction = 0.0
+
+            # volatility
+            volatility = 0.0
+            for j in range(period):
+                idx = i - j
+                if idx > 0 and idx < len(darray) and idx - 1 >= 0:
+                    volatility += abs(darray[idx] - darray[idx - 1])
+
+            # efficiency ratio
+            if volatility != 0:
+                er = abs(direction / volatility)
+            else:
+                er = 0.0
+
+            # smoothing constant
+            sc = pow(er * (fast_sc - slow_sc) + slow_sc, 2)
+
+            # Get previous KAMA
+            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_kama = prev_val
+
+            # KAMA formula
+            prev_kama = prev_kama + sc * (darray[i] - prev_kama)
+            if i < len(larray):
+                larray[i] = prev_kama

backtrader/indicators/kst.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python
+"""KST Indicator Module - Know Sure Thing indicator.
+
+This module provides the KST (Know Sure Thing) momentum indicator
+developed by Martin Pring.
+
+Classes:
+    KnowSureThing: KST indicator (alias: KST).
+
+Example:
+    class MyStrategy(bt.Strategy):
+        def __init__(self):
+            self.kst = bt.indicators.KST(self.data)
+            self.kst_signal = bt.indicators.KST(self.data, rp1=10, rp2=15, rp3=20, rp4=30)
+
+        def next(self):
+            if self.kst.kst[0] > self.kst.signal[0]:
+                self.buy()
+            elif self.kst.kst[0] < self.kst.signal[0]:
+                self.sell()
+"""
+
+import math
+
+from . import ROC100, SMA, Indicator
+
+
+class KnowSureThing(Indicator):
+    """
+    It is a "summed" momentum indicator. Developed by Martin Pring and
+    published in 1992 in Stocks & Commodities.
+
+    Formula:
+      - rcma1 = MovAv(roc100(rp1), period)
+      - rcma2 = MovAv(roc100(rp2), period)
+      - rcma3 = MovAv(roc100(rp3), period)
+      - rcma4 = MovAv(roc100(rp4), period)
+
+      - Kst = 1.0 * rcma1 + 2.0 * rcma2 + 3.0 * rcma3 + 4.0 * rcma4
+      - signal = MovAv(kst, speriod)
+
+    See:
+      - http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:know_sure_thing_kst
+
+    Params
+
+      - ``rma1``, ``rma2``, ``rma3``, ``rma4``: for the MovingAverages on ROCs
+      - ``rp1``, ``rp2``, ``rp3``, ``rp4``: for the ROCs
+      - ``rsig``: for the MovingAverage for the signal line
+      - ``rfactors``: list of factors to apply to the different MovAv(ROCs)
+      - ``_movav`` and ``_movavs``, allows to change the Moving Average type
+        applied for the calculation of kst and signal
+
+    """
+
+    alias = ("KST",)
+    lines = (
+        "kst",
+        "signal",
+    )
+    params = (
+        ("rp1", 10),
+        ("rp2", 15),
+        ("rp3", 20),
+        ("rp4", 30),
+        ("rma1", 10),
+        ("rma2", 10),
+        ("rma3", 10),
+        ("rma4", 10),
+        ("rsignal", 9),
+        ("rfactors", [1.0, 2.0, 3.0, 4.0]),
+        ("_rmovav", SMA),
+        ("_smovav", SMA),
+    )
+
+    plotinfo = {"plothlines": [0.0]}
+
+    def __init__(self):
+        """Initialize the KST indicator.
+
+        Creates 4 ROC and moving average sub-indicators.
+        """
+        super().__init__()
+        self.rcma1 = self.p._rmovav(ROC100(self.data, period=self.p.rp1), period=self.p.rma1)
+        self.rcma2 = self.p._rmovav(ROC100(self.data, period=self.p.rp2), period=self.p.rma2)
+        self.rcma3 = self.p._rmovav(ROC100(self.data, period=self.p.rp3), period=self.p.rma3)
+        self.rcma4 = self.p._rmovav(ROC100(self.data, period=self.p.rp4), period=self.p.rma4)
+
+    def next(self):
+        """Calculate KST and signal for the current bar.
+
+        Formula: KST = w1*RCMA1 + w2*RCMA2 + w3*RCMA3 + w4*RCMA4
+        Signal = SMA(KST, rsignal)
+        """
+        rf = self.p.rfactors
+        kst_val = (
+            rf[0] * self.rcma1[0]
+            + rf[1] * self.rcma2[0]
+            + rf[2] * self.rcma3[0]
+            + rf[3] * self.rcma4[0]
+        )
+        self.lines.kst[0] = kst_val
+
+        # Calculate signal (SMA of KST)
+        rsignal = self.p.rsignal
+        kst_sum = kst_val
+        for i in range(1, rsignal):
+            kst_sum += self.lines.kst[-i]
+        self.lines.signal[0] = kst_sum / rsignal
+
+    def once(self, start, end):
+        """Calculate KST and signal in runonce mode."""
+        rcma1_array = self.rcma1.lines[0].array
+        rcma2_array = self.rcma2.lines[0].array
+        rcma3_array = self.rcma3.lines[0].array
+        rcma4_array = self.rcma4.lines[0].array
+        kst_array = self.lines.kst.array
+        signal_array = self.lines.signal.array
+        rf = self.p.rfactors
+        rsignal = self.p.rsignal
+
+        for arr in [kst_array, signal_array]:
+            while len(arr) < end:
+                arr.append(float("nan"))
+
+        # Calculate KST
+        for i in range(
+            start, min(end, len(rcma1_array), len(rcma2_array), len(rcma3_array), len(rcma4_array))
+        ):
+            v1 = rcma1_array[i] if i < len(rcma1_array) else 0.0
+            v2 = rcma2_array[i] if i < len(rcma2_array) else 0.0
+            v3 = rcma3_array[i] if i < len(rcma3_array) else 0.0
+            v4 = rcma4_array[i] if i < len(rcma4_array) else 0.0
+
+            if any(isinstance(v, float) and math.isnan(v) for v in [v1, v2, v3, v4]):
+                kst_array[i] = float("nan")
+            else:
+                kst_array[i] = rf[0] * v1 + rf[1] * v2 + rf[2] * v3 + rf[3] * v4
+
+        # Calculate signal (SMA of KST)
+        for i in range(start, min(end, len(kst_array))):
+            kst_val = kst_array[i]
+            if isinstance(kst_val, float) and math.isnan(kst_val) or i < rsignal - 1:
+                signal_array[i] = float("nan")
+            else:
+                kst_sum = 0.0
+                valid = True
+                for j in range(rsignal):
+                    idx = i - j
+                    if idx >= 0 and idx < len(kst_array):
+                        val = kst_array[idx]
+                        if isinstance(val, float) and math.isnan(val):
+                            valid = False
+                            break
+                        kst_sum += val
+                if valid:
+                    signal_array[i] = kst_sum / rsignal
+                else:
+                    signal_array[i] = float("nan")