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

backtrader/indicators/contrib/sidus_indicator.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import Indicator
+
+__all__ = [
+    "SidusIndicator",
+]
+
+
+class SidusIndicator(Indicator):
+    """Reconstructs Sidus indicator from its MQ5 source.
+
+    Uses 4 MAs: FastEMA, SlowEMA, FastLWMA, SlowLWMA + ATR(15).
+    Buy arrows on: FastLWMA crosses above SlowLWMA, or SlowLWMA crosses above SlowEMA.
+    Sell arrows on reverse crosses.
+    Arrow offset = ATR * digit scaling.
+    """
+
+    lines = ("buy_arrow", "sell_arrow")
+    params = (
+        ("fast_ema", 18),
+        ("slow_ema", 28),
+        ("fast_lwma", 5),
+        ("slow_lwma", 8),
+        ("digit", 0),
+    )
+
+    def __init__(self):
+        """Cache MA periods and digit scaling, and set the indicator warmup."""
+        self._fe = int(self.p.fast_ema)
+        self._se = int(self.p.slow_ema)
+        self._fl = int(self.p.fast_lwma)
+        self._sl = int(self.p.slow_lwma)
+        self._digit = float(10 ** int(self.p.digit)) if int(self.p.digit) > 0 else 0.0
+        self.addminperiod(max(self._fe, self._se, self._fl, self._sl) + 3)
+
+    def _ema(self, period, ago):
+        # Simple EMA approximation using close prices
+        k = 2.0 / (period + 1)
+        val = float(self.data.close[-(ago + period - 1)])
+        for i in range(ago + period - 2, ago - 1, -1):
+            val = float(self.data.close[-i]) * k + val * (1 - k) if i >= 0 else val
+        return val
+
+    def _lwma(self, period, ago):
+        total = 0.0
+        wsum = 0.0
+        for i in range(period):
+            w = float(period - i)
+            total += float(self.data.close[-(ago + i)]) * w
+            wsum += w
+        return total / wsum if wsum > 0 else 0.0
+
+    def _atr(self, period, ago):
+        total = 0.0
+        for i in range(period):
+            idx = ago + i
+            h = float(self.data.high[-idx])
+            low_price = float(self.data.low[-idx])
+            if idx + 1 < len(self.data):
+                pc = float(self.data.close[-(idx + 1)])
+                tr = max(h - low_price, abs(h - pc), abs(low_price - pc))
+            else:
+                tr = h - low_price
+            total += tr
+        return total / period
+
+    def next(self):
+        """Emit buy/sell arrow offsets when the LWMA/EMA cross conditions fire."""
+        # Current bar (ago=0) and previous bar (ago=1)
+        self._ema(self._fe, 0)
+        slw_ema_0 = self._ema(self._se, 0)
+        fst_lwma_0 = self._lwma(self._fl, 0)
+        slw_lwma_0 = self._lwma(self._sl, 0)
+
+        fst_lwma_1 = self._lwma(self._fl, 1)
+        slw_lwma_1 = self._lwma(self._sl, 1)
+        slw_ema_1 = self._ema(self._se, 1)
+
+        atr_val = self._atr(15, 0)
+        rng = atr_val * 3.0
+        digit = self._digit
+
+        buy_val = 0.0
+        sell_val = 0.0
+
+        # Buy: FastLWMA crosses above SlowLWMA, or SlowLWMA crosses above SlowEMA
+        if fst_lwma_0 > slw_lwma_0 + digit and fst_lwma_1 <= slw_lwma_1:
+            buy_val = float(self.data.low[0]) - rng
+        if slw_lwma_0 > slw_ema_0 + digit and slw_lwma_1 <= slw_ema_1:
+            buy_val = float(self.data.low[0]) - rng
+
+        # Sell: FastLWMA crosses below SlowLWMA, or SlowLWMA crosses below SlowEMA
+        if fst_lwma_0 < slw_lwma_0 - digit and fst_lwma_1 >= slw_lwma_1:
+            sell_val = float(self.data.high[0]) + rng
+        if slw_lwma_0 < slw_ema_0 - digit and slw_lwma_1 >= slw_ema_1:
+            sell_val = float(self.data.high[0]) + rng
+
+        self.lines.buy_arrow[0] = buy_val
+        self.lines.sell_arrow[0] = sell_val

backtrader/indicators/contrib/silver_trend_indicator.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import Indicator
+
+__all__ = [
+    "SilverTrendIndicator",
+]
+
+
+class SilverTrendIndicator(Indicator):
+    """Reconstructs SilverTrend_Signal from its MQ5 source.
+
+    Uses SSP-period average range to compute smin/smax bands.
+    K = RISK * 100.
+    smin = SsMin + (SsMax - SsMin) * K / 100
+    smax = SsMax - (SsMax - SsMin) * K / 100
+    Trend toggles: close < smin → downtrend, close > smax → uptrend.
+    Buy arrow on uptrend toggle, sell arrow on downtrend toggle.
+    """
+
+    lines = ("buy_arrow", "sell_arrow")
+    params = (
+        ("ssp", 9),
+        ("risk", 3),
+    )
+
+    def __init__(self):
+        """Cache SSP/risk parameters, reset trend state, and set min period."""
+        self._ssp = int(self.p.ssp)
+        self._k = float(self.p.risk) * 100.0
+        self._uptrend = False
+        self._old = False
+        self.addminperiod(self._ssp + 2)
+
+    def next(self):
+        """Update the adaptive bands and emit buy/sell arrows on trend flips."""
+        ssp = self._ssp
+
+        # Compute average range over SSP bars
+        total_range = 0.0
+        for i in range(ssp):
+            h = float(self.data.high[-i])
+            low_price = float(self.data.low[-i])
+            total_range += h - low_price
+        avg_range = total_range / ssp
+        rng = avg_range
+
+        # SsMax = highest high over SSP bars, SsMin = lowest low
+        ss_max = max(float(self.data.high[-i]) for i in range(ssp))
+        ss_min = min(float(self.data.low[-i]) for i in range(ssp))
+
+        k = self._k
+        smin = ss_min + (ss_max - ss_min) * k / 100.0
+        smax = ss_max - (ss_max - ss_min) * k / 100.0
+
+        cur_close = float(self.data.close[0])
+
+        if cur_close < smin:
+            self._uptrend = False
+        if cur_close > smax:
+            self._uptrend = True
+
+        buy_val = 0.0
+        sell_val = 0.0
+
+        if self._uptrend != self._old and self._uptrend:
+            buy_val = float(self.data.low[0]) - rng * 0.5
+        if self._uptrend != self._old and not self._uptrend:
+            sell_val = float(self.data.high[0]) + rng * 0.5
+
+        self._old = self._uptrend
+
+        self.lines.buy_arrow[0] = buy_val
+        self.lines.sell_arrow[0] = sell_val

backtrader/indicators/contrib/sliding_range_color.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import Indicator
+
+__all__ = [
+    "SlidingRangeColor",
+]
+
+
+class SlidingRangeColor(Indicator):
+    """Indicator computing sliding-window average range channels with a color index for breakout direction."""
+
+    lines = ("color_idx", "upper", "lower")
+    params = (
+        ("up_calc_period_range", 5),
+        ("up_calc_period_shift", 0),
+        ("dn_calc_period_range", 5),
+        ("dn_calc_period_shift", 0),
+        ("up_digit", 2),
+        ("dn_digit", 2),
+    )
+
+    def next(self):
+        """Compute rounded average of recent highs/lows and set color based on close relative to the range."""
+        up_end = len(self.data) - 1 - self.p.up_calc_period_shift
+        up_start = max(0, up_end - self.p.up_calc_period_range + 1)
+        dn_end = len(self.data) - 1 - self.p.dn_calc_period_shift
+        dn_start = max(0, dn_end - self.p.dn_calc_period_range + 1)
+        highs = [
+            float(self.data.high[-idx])
+            for idx in range(len(self.data) - 1 - up_end, len(self.data) - up_start)
+        ]
+        lows = [
+            float(self.data.low[-idx])
+            for idx in range(len(self.data) - 1 - dn_end, len(self.data) - dn_start)
+        ]
+        if not highs or not lows:
+            self.lines.color_idx[0] = 4.0
+            return
+        upper = round(sum(highs) / len(highs), self.p.up_digit)
+        lower = round(sum(lows) / len(lows), self.p.dn_digit)
+        close = float(self.data.close[0])
+        open_ = float(self.data.open[0])
+        self.lines.upper[0] = upper
+        self.lines.lower[0] = lower
+        color = 4.0
+        if close > upper:
+            color = 3.0 if close >= open_ else 2.0
+        elif close < lower:
+            color = 0.0 if close <= open_ else 1.0
+        self.lines.color_idx[0] = color

backtrader/indicators/contrib/slow_stoch.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import (
+    ExponentialMovingAverage,
+    Indicator,
+    StochasticFull,
+)
+
+__all__ = [
+    "SlowStoch",
+]
+
+
+class SlowStoch(Indicator):
+    """EMA-smoothed slow stochastic exposing an oscillator and a signal line."""
+
+    lines = ("sto", "signal")
+    params = (
+        ("k_period", 5),
+        ("d_period", 3),
+        ("slowing", 3),
+        ("xlength", 5),
+    )
+
+    def __init__(self):
+        """Build the StochasticFull and EMA-smooth its %D and slow %D lines."""
+        stoch = StochasticFull(
+            self.data,
+            period=max(int(self.p.k_period), 1),
+            period_dfast=max(int(self.p.d_period), 1),
+            period_dslow=max(int(self.p.slowing), 1),
+            safediv=True,
+        )
+        self.l.sto = ExponentialMovingAverage(stoch.percD, period=max(int(self.p.xlength), 1))
+        self.l.signal = ExponentialMovingAverage(
+            stoch.percDSlow, period=max(int(self.p.xlength), 1)
+        )

backtrader/indicators/contrib/smoothed_adx_indicator.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import (
+    ADX,
+    ExponentialMovingAverage,
+    Indicator,
+    MinusDirectionalIndicator,
+    PlusDirectionalIndicator,
+    SimpleMovingAverage,
+    SmoothedMovingAverage,
+    WeightedMovingAverage,
+)
+
+__all__ = [
+    "SmoothedADXIndicator",
+]
+
+
+def resolve_ma_class(name):
+    """Map a moving-average name to its backtrader indicator class.
+
+    Args:
+        name: MA type name (e.g. ``t3``, ``ema``, ``sma``, ``smma`` or MT5-style
+            ``mode_*`` variants); several smoothing variants map to EMA.
+
+    Returns:
+        The matching backtrader moving-average indicator class, defaulting to
+        the weighted moving average for unrecognized names.
+    """
+    mode = str(name).lower()
+    if mode in {
+        "mode_t3",
+        "t3",
+        "mode_ema",
+        "ema",
+        "mode_ama",
+        "ama",
+        "mode_jjma",
+        "jjma",
+        "mode_jurx",
+        "jurx",
+        "mode_vidya",
+        "vidya",
+        "mode_parma",
+        "parma",
+    }:
+        return ExponentialMovingAverage
+    if mode in {"mode_sma", "sma"}:
+        return SimpleMovingAverage
+    if mode in {"mode_smma", "smma"}:
+        return SmoothedMovingAverage
+    return WeightedMovingAverage
+
+
+class SmoothedADXIndicator(Indicator):
+    """ADX/DI system with each line smoothed by a configurable moving average.
+
+    Computes raw +DI, -DI and ADX over ``adx_period`` and exposes moving-average
+    smoothed versions on the ``plus_di``, ``minus_di`` and ``adx`` lines.
+    """
+
+    lines = ("plus_di", "minus_di", "adx")
+    params = (
+        ("xma_method", "t3"),
+        ("adx_period", 14),
+        ("adx_phase", 100),
+    )
+
+    def __init__(self):
+        """Build the raw +DI/-DI/ADX indicators and their smoothed lines."""
+        ma_cls = resolve_ma_class(self.p.xma_method)
+        self._plus = PlusDirectionalIndicator(self.data, period=max(1, int(self.p.adx_period)))
+        self._minus = MinusDirectionalIndicator(self.data, period=max(1, int(self.p.adx_period)))
+        self._adx_raw = ADX(self.data, period=max(1, int(self.p.adx_period)))
+        self._plus_smooth = ma_cls(self._plus, period=max(1, int(self.p.adx_period)))
+        self._minus_smooth = ma_cls(self._minus, period=max(1, int(self.p.adx_period)))
+        self._adx_smooth = ma_cls(self._adx_raw, period=max(1, int(self.p.adx_period)))
+        self.lines.plus_di = self._plus_smooth
+        self.lines.minus_di = self._minus_smooth
+        self.lines.adx = self._adx_smooth
+        self.addminperiod(int(self.p.adx_period) * 3)

backtrader/indicators/contrib/smoothed_rsi.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import (
+    RSI,
+    Indicator,
+    SimpleMovingAverage,
+)
+
+__all__ = [
+    "SmoothedRsi",
+]
+
+
+class SmoothedRsi(Indicator):
+    """Smooth RSI value using an outer simple moving average."""
+
+    lines = ("value",)
+    params = (
+        ("period", 14),
+        ("smoothing", 6),
+    )
+
+    def __init__(self):
+        """Initialize RSI and smoothed value lines from configured parameters."""
+        rsi = RSI(self.data, period=self.p.period)
+        self.lines.value = SimpleMovingAverage(rsi, period=self.p.smoothing)

backtrader/indicators/contrib/spearman_rank_correlation_histogram.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import Indicator
+
+__all__ = [
+    "SpearmanRankCorrelationHistogram",
+]
+
+
+class SpearmanRankCorrelationHistogram(Indicator):
+    """Compute a Spearman-rank-style correlation histogram and regime color."""
+
+    lines = ("value", "color")
+    params = (
+        ("range_n", 14),
+        ("direction", True),
+        ("in_high_level", 0.5),
+        ("in_low_level", -0.5),
+    )
+
+    def __init__(self):
+        """Set the indicator minimum period."""
+        self.addminperiod(int(self.p.range_n) + 2)
+
+    def _ranks(self, values):
+        indexed = list(enumerate(values))
+        sorted_values = sorted(indexed, key=lambda item: item[1], reverse=bool(self.p.direction))
+        ranks = [0.0] * len(values)
+        i = 0
+        while i < len(sorted_values):
+            j = i + 1
+            while j < len(sorted_values) and sorted_values[j][1] == sorted_values[i][1]:
+                j += 1
+            avg_rank = (i + 1 + j) / 2.0
+            for k in range(i, j):
+                ranks[sorted_values[k][0]] = avg_rank
+            i = j
+        return ranks
+
+    def next(self):
+        """Compute one step of correlation value and color code."""
+        n = int(self.p.range_n)
+        values = [int(round(float(self.data.close[-i]) * 100.0)) for i in range(n)]
+        ranks = self._ranks(values)
+        z2 = 0.0
+        for i, rank in enumerate(ranks):
+            z2 += (rank - (i + 1)) ** 2
+        res = 1.0 - 6.0 * z2 / (n**3 - n)
+        self.lines.value[0] = res
+        clr = 2
+        if res > 0:
+            clr = 4 if res > float(self.p.in_high_level) else 3
+        elif res < 0:
+            clr = 0 if res < float(self.p.in_low_level) else 1
+        self.lines.color[0] = clr

backtrader/indicators/contrib/stalin_indicator.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import Indicator
+
+__all__ = [
+    "StalinIndicator",
+]
+
+
+class StalinIndicator(Indicator):
+    """Reconstructs Stalin indicator from its MQ5 source.
+
+    Uses Fast/Slow MA crossover with optional RSI filter.
+    BU() fires buy arrow at low if flat distance check passes.
+    BD() fires sell arrow at high if flat distance check passes.
+    Optional Confirm parameter adds a price-distance confirmation step.
+    """
+
+    lines = ("buy_arrow", "sell_arrow")
+    params = (
+        ("ma_method", "ema"),
+        ("fast", 14),
+        ("slow", 21),
+        ("rsi_period", 17),
+        ("confirm", 0),
+        ("flat", 0),
+        ("point", 0.0001),
+    )
+
+    def __init__(self):
+        """Prepare cached MA/RSI parameters and state for BU/BD arrow generation."""
+        self._fast = int(self.p.fast)
+        self._slow = int(self.p.slow)
+        self._rsi = int(self.p.rsi_period)
+        self._confirm2 = float(self.p.confirm) * float(self.p.point)
+        self._flat2 = float(self.p.flat) * float(self.p.point)
+        self._e1 = 0.0  # last buy arrow price
+        self._e2 = 0.0  # last sell arrow price
+        self._iup = 0.0  # pending buy confirmation price
+        self._idn = 0.0  # pending sell confirmation price
+        self.addminperiod(max(self._fast, self._slow, self._rsi if self._rsi > 0 else 1) + 3)
+
+    def _calc_ema(self, period, ago):
+        k = 2.0 / (period + 1)
+        val = float(self.data.close[-(ago + period - 1)])
+        for i in range(ago + period - 2, ago - 1, -1):
+            val = float(self.data.close[-i]) * k + val * (1 - k) if i >= 0 else val
+        return val
+
+    def _calc_lwma(self, period, ago):
+        total = 0.0
+        wsum = 0.0
+        for i in range(period):
+            w = float(period - i)
+            total += float(self.data.close[-(ago + i)]) * w
+            wsum += w
+        return total / wsum if wsum > 0 else 0.0
+
+    def _calc_sma(self, period, ago):
+        total = 0.0
+        for i in range(period):
+            total += float(self.data.close[-(ago + i)])
+        return total / period
+
+    def _calc_ma(self, period, ago):
+        method = str(self.p.ma_method).lower()
+        if method == "lwma":
+            return self._calc_lwma(period, ago)
+        if method == "sma":
+            return self._calc_sma(period, ago)
+        return self._calc_ema(period, ago)
+
+    def _calc_rsi(self, period, ago):
+        gains = 0.0
+        losses = 0.0
+        for i in range(period):
+            idx = ago + i
+            c = float(self.data.close[-idx])
+            cp = float(self.data.close[-(idx + 1)])
+            diff = c - cp
+            if diff > 0:
+                gains += diff
+            else:
+                losses -= diff
+        avg_gain = gains / period
+        avg_loss = losses / period
+        if avg_loss == 0:
+            return 100.0
+        rs = avg_gain / avg_loss
+        return 100.0 - (100.0 / (1.0 + rs))
+
+    def next(self):
+        """Compute MA crossover and optional RSI filters, then emit buy/sell arrows."""
+        fast_ma_0 = self._calc_ma(self._fast, 0)
+        slow_ma_0 = self._calc_ma(self._slow, 0)
+        fast_ma_1 = self._calc_ma(self._fast, 1)
+        slow_ma_1 = self._calc_ma(self._slow, 1)
+
+        use_rsi = self._rsi > 0
+        rsi_val = self._calc_rsi(self._rsi, 0) if use_rsi else 50.0
+
+        buy_val = 0.0
+        sell_val = 0.0
+
+        cur_low = float(self.data.low[0])
+        cur_high = float(self.data.high[0])
+        cur_close = float(self.data.close[0])
+        flat2 = self._flat2
+        confirm2 = self._confirm2
+
+        # MA crossover buy signal
+        if (not use_rsi) or (fast_ma_1 < slow_ma_1 and fast_ma_0 > slow_ma_0 and rsi_val > 50):
+            if not confirm2:
+                # BU: fire buy arrow if flat distance passes
+                if cur_low >= (self._e1 + flat2) or cur_low <= (self._e1 - flat2):
+                    buy_val = cur_low
+                    self._e1 = cur_low
+            else:
+                self._iup = cur_low
+                self._idn = 0.0
+
+        # MA crossover sell signal
+        if (not use_rsi) or (fast_ma_1 > slow_ma_1 and fast_ma_0 < slow_ma_0 and rsi_val < 50):
+            if not confirm2:
+                if cur_high >= (self._e2 + flat2) or cur_high <= (self._e2 - flat2):
+                    sell_val = cur_high
+                    self._e2 = cur_high
+            else:
+                self._idn = cur_high
+                self._iup = 0.0
+
+        # Confirm pending buy
+        if self._iup and cur_high - self._iup >= confirm2 and cur_close <= cur_high:
+            if cur_low >= (self._e1 + flat2) or cur_low <= (self._e1 - flat2):
+                buy_val = cur_low
+                self._e1 = cur_low
+            self._iup = 0.0
+
+        # Confirm pending sell
+        if self._idn and self._idn - cur_low >= confirm2 and float(self.data.open[0]) >= cur_close:
+            if cur_high >= (self._e2 + flat2) or cur_high <= (self._e2 - flat2):
+                sell_val = cur_high
+                self._e2 = cur_high
+            self._idn = 0.0
+
+        self.lines.buy_arrow[0] = buy_val
+        self.lines.sell_arrow[0] = sell_val

backtrader/indicators/contrib/starter_laguerre_filter.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+"""Functional-test indicators migrated to contrib.
+
+Generated from a single functional strategy module to preserve file-local
+helper functions and constants without cross-test name collisions.
+"""
+
+from .. import Indicator
+
+__all__ = [
+    "StarterLaguerreFilter",
+]
+
+
+class StarterLaguerreFilter(Indicator):
+    """Laguerre filter oscillator bounded in the [0, 1] range.
+
+    Implements Ehlers' four-stage Laguerre filter and converts the staged
+    values into a normalised oscillator. Readings near 0 indicate oversold
+    conditions and readings near 1 indicate overbought conditions.
+    """
+
+    lines = ("value",)
+    params = (("gamma", 0.7),)
+
+    def __init__(self):
+        """Set the minimum period and reset the four Laguerre stage buffers."""
+        self.addminperiod(2)
+        self._l0 = None
+        self._l1 = None
+        self._l2 = None
+        self._l3 = None
+
+    def next(self):
+        """Advance the Laguerre stages and emit the normalised oscillator value."""
+        price = float(self.data[0])
+        gamma = float(self.p.gamma)
+        if self._l0 is None:
+            self._l0 = price
+            self._l1 = price
+            self._l2 = price
+            self._l3 = price
+            self.lines.value[0] = 0.5
+            return
+        l0_prev = self._l0
+        l1_prev = self._l1
+        l2_prev = self._l2
+        l3_prev = self._l3
+        self._l0 = (1.0 - gamma) * price + gamma * l0_prev
+        self._l1 = -gamma * self._l0 + l0_prev + gamma * l1_prev
+        self._l2 = -gamma * self._l1 + l1_prev + gamma * l2_prev
+        self._l3 = -gamma * self._l2 + l2_prev + gamma * l3_prev
+        cu = 0.0
+        cd = 0.0
+        pairs = ((self._l0, self._l1), (self._l1, self._l2), (self._l2, self._l3))
+        for left, right in pairs:
+            if left >= right:
+                cu += left - right
+            else:
+                cd += right - left
+        denom = cu + cd
+        self.lines.value[0] = cu / denom if denom else self.lines.value[-1]