opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/lib/ta.py

@@ -0,0 +1,2230 @@
+"""
+@pyne lib
+"""
+from typing import TypeVar, cast, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pynecore.types.type_checker import *
+
+import builtins
+import math
+import heapq
+
+from collections import deque
+
+from ..types import Series, Persistent, NA, PyneFloat, PyneInt, PyneBool, na_float
+from ..core.module_property import module_property, module_function_property
+from pynecore.core.overload import overload
+
+from ..core import safe_convert
+
+# We need to use this kind of import to make transformer work
+from pynecore.lib import (open, high, low, close, volume, hl2, hlc3, bar_index, array, session,
+                          max_bars_back, math as lib_math)
+
+TFIB = TypeVar('TFIB', float, int, bool)
+TFI = TypeVar('TFI', float, int)
+
+__all__ = [
+    "accdist",
+    "alma",
+    "atr",
+    "barssince",
+    "bb",
+    "bbw",
+    "cci",
+    "change",
+    "cmo",
+    "cog",
+    "correlation",
+    "cross",
+    "crossover",
+    "crossunder",
+    "cum",
+    "dev",
+    "dmi",
+    "ema",
+    "falling",
+    "highest",
+    "highestbars",
+    "hma",
+    "iii",
+    "kc",
+    "kcw",
+    "linreg",
+    "lowest",
+    "lowestbars",
+    "macd",
+    "max",
+    "median",
+    "mfi",
+    "min",
+    "mode",
+    "mom",
+    "nvi",
+    "obv",
+    "percentile_linear_interpolation",
+    "percentile_nearest_rank",
+    "percentrank",
+    "pivot_point_levels",
+    "pivothigh",
+    "pivotlow",
+    "pvi",
+    "pvt",
+    "range",
+    "rci",
+    "rising",
+    "rma",
+    "roc",
+    "rsi",
+    "sar",
+    "sma",
+    "stdev",
+    "stoch",
+    "supertrend",
+    "swma",
+    "tr",
+    "tsi",
+    "valuewhen",
+    "variance",
+    "vwap",
+    "vwma",
+    "wad",
+    "wma",
+    "wpr",
+    "wvad"
+]
+
+#
+# Helper functions
+#
+
+EPSILON = 1e-14
+
+
+def _avgrank(values: list[float], val_to_compare: float) -> float:
+    """
+    Helper function to calculate rank with proper tie handling
+
+    :param values: The list of values
+    :param val_to_compare: The value to compare
+    :return: The average rank of the value
+    """
+    rank_sum = 0.0
+    tie_count = 0
+
+    # Count values less than current and ties
+    for vi in values:
+        diff = vi - val_to_compare
+        if diff > EPSILON:
+            rank_sum += 1
+        elif abs(diff) < EPSILON:
+            tie_count += 1
+
+    # Return average rank for ties
+    return rank_sum + (tie_count - 1) / 2.0 + 1
+
+
+#
+# Indicators
+#
+
+@module_property
+def accdist() -> PyneFloat:
+    """
+    Accumulation/Distribution index
+    A/D = ((Close - Low) - (High - Close)) / (High - Low) * Volume + Previous A/D
+
+    :return: Accumulation/Distribution index
+    """
+    ad: Persistent[float] = 0.0
+
+    mfm = ((close - low) - (high - close)) / (high - low)
+    mfv = mfm * volume
+    if not (isinstance(mfv, NA) or mfv != mfv):
+        ad += mfv
+
+    return ad
+
+
+def alma(source: Series[float], length: int, offset: float = 0.85, sigma: float = 6.0, floor=False) \
+        -> PyneFloat:
+    """
+    Calculate the Arnaud Legoux Moving Average (ALMA) of the source series with the given length.
+
+    Fun fact: ALMA means "soul" in latin and Spanish, and Portugese.
+              It means "apple" in Hungarian, Finnish, and Estonian.
+              It means "take it" in Turkish.
+              It means "water" in Arabic.
+              It means "apple tree" in Georgian.
+              ...
+
+    :param source: The source series
+    :param length: The length of the ALMA
+    :param offset: The offset of the ALMA
+    :param sigma: The sigma value of the ALMA
+    :param floor:  Specifies whether the offset calculation is floored before ALMA is calculated. Default value is false
+    :return: The ALMA of the source series
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    if (isinstance(source, NA) or source != source):
+        return na_float
+    length = int(length)
+
+    # Use persistent weights to avoid recalculation
+    weights: Persistent[list[float]] = []
+    norm: Persistent[float] = 0.0
+
+    # Calculate weights only once
+    if not weights:
+        m = offset * (length - 1) if not floor else math.floor(offset * (length - 1))
+        s = length / sigma
+        weights = [math.exp(-1 * ((i - m) * (i - m)) / (2 * s * s)) for i in builtins.range(length)]
+        weights.reverse()  # This is faster then using backward range or index subtraction
+        norm = sum(weights)
+
+    # Vectorized calculation using dot product
+    summ = 0.0
+    for i, w in enumerate(weights):
+        summ += w * source[i]
+    return summ / norm
+
+
+def atr(length: int) -> PyneFloat:
+    """
+    Calculate Average True Range (ATR) of the source series with the given length.
+
+    :param length: The length of the ATR
+    :return: The ATR of the source series
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    return rma(tr(True), length)
+
+
+def barssince(condition: bool) -> PyneInt:
+    """
+    Calculate the number of bars since the condition was true.
+
+    :param condition: The condition to check
+    :return: The number of bars since the condition was true
+    """
+    counter: Persistent[int] = -1
+    if condition:
+        counter = 0
+    elif counter == -1:
+        return NA(int)
+    else:
+        counter += 1
+    return counter
+
+
+def bb(source: float, length: int, mult: float | int) -> tuple[PyneFloat, PyneFloat, PyneFloat]:
+    """
+    Calculate the Bollinger Bands (BB) of the source series with the given length and multiplier.
+
+    :param source: The source series
+    :param length: The length of the BB
+    :param mult: The multiplier of the BB
+    :return: The Bollinger Bands (BB) of the source series
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    assert mult > 0, "Invalid multiplier, multiplier must be greater than 0!"
+
+    std_dev = stdev(source, length)
+
+    middle = sma(source, length)
+
+    if (isinstance(middle, NA) or middle != middle):
+        return na_float, na_float, na_float
+    std_dev *= mult
+    return middle, middle + std_dev, middle - std_dev
+
+
+def bbw(source: float, length: int, mult: float | int) -> PyneFloat:
+    """
+    Calculate the Bollinger Bands Width (BBW) of the source series with the given length and multiplier.
+
+    :param source: The source series
+    :param length: The length of the BBW
+    :param mult: The multiplier of the BBW
+    :return: The Bollinger Bands Width (BBW) of the source series
+    """
+    b, h, l = bb(source, length, mult)
+    if (isinstance(b, NA) or b != b) or b == 0.0:
+        return na_float
+    return ((h - l) / b) * 100
+
+
+def cci(source: float, length: int) -> PyneFloat:
+    """
+    Calculate the Commodity Channel Index (CCI) of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the CCI
+    :return: The Commodity Channel Index (CCI) of the source series
+    """
+    mean = sma(source, length)
+    mdev = dev(source, length, _mean=mean)
+    if (isinstance(mdev, NA) or mdev != mdev):
+        return na_float
+    return (source - mean) / (0.015 * mdev)
+
+
+def change(source: Series[TFIB], length: int = 1) -> TFIB:
+    """
+    Calculate a simple change with respect to the given bar offset.
+
+    :param source: The source series
+    :param length: The offset in bars
+    :return: The change from source to source[length]
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    length = int(length)
+    # Grow the buffer so ``source[length]`` stays addressable for lengths beyond the
+    # per-series default max_bars_back (500); otherwise it reads na and the change is na.
+    max_bars_back(source, length)
+
+    # We need to round to prevent problems caused by floating point precision
+    if isinstance(source, (float, int)):
+        # The cast is for pyright: it types round(float) as float, which is not
+        # assignable back to the TFIB-typed parameter; PyCharm resolves it to
+        # TFIB already.
+        # noinspection PyUnnecessaryCast
+        source = cast(TFIB, round(source, 14))
+    prev_val = source[length]  # noqa
+
+    if (isinstance(source, NA) or source != source):
+        # type(source) would be the NA class itself — keep the source sentinel's type
+        return cast(TFIB, source)
+    if (isinstance(prev_val, NA) or prev_val != prev_val):
+        return NA(type(source))
+    if isinstance(source, float):
+        return cast(TFIB, round(source - prev_val, 14))  # noqa
+    if isinstance(source, int):
+        return cast(TFIB, source - prev_val)  # noqa
+    return source != prev_val
+
+
+def cmo(source: float, length: int) -> PyneFloat:
+    """
+    Calculate the Chande Momentum Oscillator (CMO) of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the CMO
+    :return: The Chande Momentum Oscillator (CMO) of the source series
+    """
+    momentum = change(source)
+    if (isinstance(momentum, NA) or momentum != momentum):
+        return na_float
+    sum1 = lib_math.sum(momentum if momentum >= 0.0 else 0.0, length)
+    sum2 = lib_math.sum(0.0 if momentum >= 0.0 else -momentum, length)
+    return 100 * (sum1 - sum2) / (sum1 + sum2)
+
+
+# noinspection PyUnusedLocal,PyShadowingBuiltins
+def cog(source: Series[float], length: int) -> PyneFloat:
+    """
+    Calculate the Center of Gravity (COG) of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the COG
+    :return: The Center of Gravity (COG) of the source series
+    """
+    count: Persistent[int] = 0
+    summ: Persistent[float] = 0.0
+    weighted_summ: Persistent[float] = 0.0
+    val: Persistent[float] = na_float
+
+    if (isinstance(source, NA) or source != source):
+        # An NA bar leaves the window unchanged; hold the last full value
+        # (still NA while warming up)
+        return na_float if count < length else val
+
+    # NA values are NOT stored in the buffer, only skipped, so ``src[length]``
+    # indexes past NA gaps to the true oldest value still inside the window.
+    # Reading the parameter directly would step back ``length`` *bars* and land
+    # inside an NA gap, subtracting an NA that poisons ``summ`` forever.
+    src: Series[float] = source
+    # Grow the na-compacted buffer so ``src[length]`` stays addressable for lengths
+    # beyond the per-series default max_bars_back (500); otherwise the window-drop
+    # read returns na and poisons ``summ`` permanently.
+    max_bars_back(src, int(length))
+
+    # Warming up phase — only non-NA samples advance the window
+    if count < length:
+        count += 1
+        summ += source
+        weighted_summ += source * (length - count)
+        if count < length:
+            return na_float
+
+    # Normal calculation phase
+    else:
+        new_summ = summ + source - src[length]
+        weighted_summ = weighted_summ + summ - length * src[length]
+        summ = new_summ
+    val = -weighted_summ / summ - 1.0
+    return val
+
+
+def correlation(source1: Series[float], source2: Series[float], length: int) -> PyneFloat:
+    """
+    Calculate the correlation of the source series with the given length.
+
+    NOTE: It is about 7 digits accurate to the result of Pine Script's correlation function. There
+          are a lot of floating point operations, and even the order matters. I cannot found a
+          better matching calculation.
+
+    :param source1: The first source series
+    :param source2: The second source series
+    :param length: The length of the correlation
+    :return: The correlation of the source series
+    """
+    assert length > 0, "Length must be greater than 0"
+    length = int(length)
+    # Grow both buffers so ``source1/source2[length]`` stay addressable for lengths beyond
+    # the per-series default max_bars_back (500); otherwise the window-drop reads na and
+    # poisons the running sums permanently.
+    max_bars_back(source1, length)
+    max_bars_back(source2, length)
+
+    sum_x: Persistent[float] = 0.0
+    sum_y: Persistent[float] = 0.0
+    sum_xy: Persistent[float] = 0.0
+    sum_x2: Persistent[float] = 0.0
+    sum_y2: Persistent[float] = 0.0
+    count: Persistent[int] = 0
+    na_window: Persistent[int] = 0
+
+    cur_na = (isinstance(source1, NA) or source1 != source1) or (isinstance(source2, NA) or source2 != source2)
+
+    if count < length:
+        # Still filling the window; no bar leaves it yet.
+        if cur_na:
+            na_window += 1
+        else:
+            sum_x += source1
+            sum_y += source2
+            sum_xy += source1 * source2
+            sum_x2 += source1 * source1
+            sum_y2 += source2 * source2
+        count += 1
+        if count < length:
+            return na_float
+    else:
+        old1 = source1[length]
+        old2 = source2[length]
+        old_na = (isinstance(old1, NA) or old1 != old1) or (isinstance(old2, NA) or old2 != old2)
+        if not cur_na and not old_na:
+            # na-free fast path: same operations and order as before, to keep the
+            # documented ~7-digit match with Pine's correlation.
+            sum_x += source1 - old1
+            sum_y += source2 - old2
+            sum_xy += (source1 * source2) - (old1 * old2)
+            sum_x2 += (source1 * source1) - (old1 * old1)
+            sum_y2 += (source2 * source2) - (old2 * old2)
+        else:
+            # A na entered or left the window: keep the running sums over the
+            # valid bars only and track how many na sit in the window.
+            if cur_na:
+                na_window += 1
+            else:
+                sum_x += source1
+                sum_y += source2
+                sum_xy += source1 * source2
+                sum_x2 += source1 * source1
+                sum_y2 += source2 * source2
+            if old_na:
+                na_window -= 1
+            else:
+                sum_x -= old1
+                sum_y -= old2
+                sum_xy -= old1 * old2
+                sum_x2 -= old1 * old1
+                sum_y2 -= old2 * old2
+
+    if na_window:
+        return na_float
+    try:
+        numerator = (length * sum_xy) - (sum_x * sum_y)
+        denominator = math.sqrt((length * sum_x2 - sum_x * sum_x) * (length * sum_y2 - sum_y * sum_y))
+        return numerator / denominator
+    except (ValueError, ZeroDivisionError):
+        return na_float
+
+
+def cross(source1: float, source2: float) -> PyneBool:
+    """
+    Check if the source series crossed over or under the given series.
+
+    :param source1: The first source series
+    :param source2: The second source series
+    :return: True if the source series crossed over the given series
+    """
+    return crossover(source1, source2) or crossunder(source1, source2)
+
+
+# noinspection PyUnusedLocal
+def crossover(source1: float, source2: float) -> PyneBool:
+    """
+    Check if the source series crossed over the given series.
+
+    :param source1: The first source series
+    :param source2: The second source series
+    :return: True if the source series crossed over the given series
+    """
+    l1_lte_l2: Persistent[bool] = NA(bool)
+    res = source1 > source2 and l1_lte_l2
+    # Only refresh the relation on bars where it is defined; TV compares against the
+    # last bar with both sources present, so na gaps must not reset the state
+    if not ((isinstance(source1, NA) or source1 != source1) or (isinstance(source2, NA) or source2 != source2)):
+        l1_lte_l2 = source1 <= source2
+    return res
+
+
+# noinspection PyUnusedLocal
+def crossunder(source1: float, source2: float) -> PyneBool:
+    """
+    Check if the source series crossed under the given series.
+
+    :param source1: The first source series
+    :param source2: The second source series
+    :return: True if the source series crossed under the given series
+    """
+    l1_gte_l2: Persistent[bool] = NA(bool)
+    res = source1 < source2 and l1_gte_l2
+    # Only refresh the relation on bars where it is defined; TV compares against the
+    # last bar with both sources present, so na gaps must not reset the state
+    if not ((isinstance(source1, NA) or source1 != source1) or (isinstance(source2, NA) or source2 != source2)):
+        l1_gte_l2 = source1 >= source2
+    return res
+
+
+def cum(source: Series[float | int]) -> PyneFloat:
+    """
+    Calculate the cumulative sum of the source series.
+
+    :param source: The source series
+    :return: The cumulative sum of the source series
+    """
+    if (isinstance(source, NA) or source != source):
+        return na_float
+    var: Persistent[float] = 0.0
+    var += source
+    return var
+
+
+def dev(source: Series[float], length: int, _mean: PyneFloat | None = None) -> PyneFloat:
+    """
+    Calculate the Mean Absolute Deviation (MAD) of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the MAD calculation
+    :param _mean: The mean value of the source series, if it is already calculated
+    :return: The mean absolute deviation of the source series
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    if length == 1:
+        return 0.0
+    length = int(length)
+
+    mean = _mean if _mean is not None else sma(source, length)
+    if (isinstance(mean, NA) or mean != mean):
+        return na_float
+
+    summ = 0.0
+    for i in builtins.range(length):
+        summ += abs(source[i] - mean)
+
+    return summ / length
+
+
+# noinspection PyPep8Naming
+def dmi(diLength: int, adxSmoothing: int) -> tuple[PyneFloat, PyneFloat, PyneFloat]:
+    """
+    Calculate the Directional Movement Index (DMI) of the source series with the given DI length and ADX smoothing.
+
+    :param diLength: The length of the DI
+    :param adxSmoothing: The smoothing of the ADX
+    :return: Tuple of three DMI series:
+             - Positive Directional Movement (+DI)
+             - Negative Directional Movement (-DI)
+             - Average Directional Movement Index (ADX)
+    """
+    assert diLength > 0, "Invalid DI length, DI length must be greater than 0!"
+    assert adxSmoothing > 0, "Invalid ADX smoothing, ADX smoothing must be greater than 0!"
+    up = change(high)
+    down = -change(low)
+    if (isinstance(up, NA) or up != up) or (isinstance(down, NA) or down != down):
+        return na_float, na_float, na_float
+    a = atr(diLength)
+    plus_dm = up if (up > down and up > 0.0) else 0.0
+    minus_dm = down if (down > up and down > 0.0) else 0.0
+    p = rma(plus_dm, diLength)
+    m = rma(minus_dm, diLength)
+    if (isinstance(a, NA) or a != a) or (isinstance(p, NA) or p != p) or (isinstance(m, NA) or m != m) or a == 0.0:
+        return na_float, na_float, na_float
+    p = 100 * p / a
+    m = 100 * m / a
+    summ = p + m
+    adx = rma(abs(p - m) / (summ if summ != 0.0 else 1.0), adxSmoothing) * 100
+    return p, m, adx
+
+
+def ema(source: PyneFloat, length: int, _alpha: float | None = None) -> PyneFloat:
+    """
+    Calculate the Exponential Moving Average (EMA) of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the EMA
+    :param _alpha: The alpha value for EMA calculation (it is a private argument)
+    :return:
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    length = int(length)
+    if length == 1:  # Shortcut
+        return source
+
+    if (isinstance(source, NA) or source != source):
+        return na_float
+
+    alpha: Persistent[float] = _alpha or (2 / (length + 1))
+    last_val: Persistent[float] = na_float
+
+    # Use SMA at warming stage
+    if (isinstance(last_val, NA) or last_val != last_val):
+        last_val = sma(source, length)
+        return last_val
+
+    # Warmed result
+    last_val = alpha * source + (1 - alpha) * last_val
+    return last_val
+
+
+# noinspection PyUnusedLocal
+def falling(source: float, length: int) -> bool:
+    """
+    Test if the source series is now falling for length bars long.
+
+    :param source: The source series
+    :param length: The length of the falling test
+    :return: True if the source series is falling for length bars long
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    length = int(length)
+
+    last_val: Persistent[float] = na_float
+    counter: Persistent[int] = 0
+
+    if (isinstance(last_val, NA) or last_val != last_val):
+        last_val = source
+        return False
+
+    if source < last_val:
+        counter += 1
+    else:
+        counter = 0
+
+    last_val = source
+    return counter >= length
+
+
+# noinspection PyUnusedLocal,DuplicatedCode
+@overload
+def highest(source: Series[float], length: int, _bars: bool = False, _tuple: bool = False, _check_eq: bool = False) \
+        -> PyneFloat:
+    """
+    Calculate the highest value of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the highest value
+    :param _bars: If true, return the number of bars since the highest value, internal use only
+    :param _tuple: If true, return a tuple of the highest value and the number of bars since the highest value,
+                   internal use only
+    :param _check_eq: If true, check for equality too, internal use only
+    :return: The highest value of the source series
+    """
+    last_max: Persistent[float] = na_float
+    last_max_index: Persistent[int] = 0
+
+    if last_max < source or (isinstance(last_max, NA) or last_max != last_max) or (_check_eq and last_max == source):
+        last_max = source
+        last_max_index = 0
+
+    if last_max_index >= length:
+        last_max = source
+        last_max_index = 0
+        for i in builtins.range(1, length):
+            s = source[i]
+            if s > last_max:
+                last_max = s
+                last_max_index = i
+            elif not _check_eq and s == last_max:
+                # For normal highest: update index for equal values
+                last_max_index = i
+            # For pivot detection (_check_eq=True): don't update index for equal values
+
+    max_index = last_max_index
+    last_max_index += 1
+
+    if bar_index < length - 1:
+        return na_float if not _tuple else (na_float, na_float)  # type: ignore[return-value]
+
+    if _bars:
+        return -max_index
+    if _tuple:
+        return last_max, -max_index  # type: ignore[return-value]
+    return last_max
+
+
+@overload
+def highest(length: int) -> PyneFloat:
+    return highest(high, length)
+
+
+# noinspection PyUnusedLocal
+@overload
+def highestbars(source: Series[float], length: int) -> PyneFloat:
+    """
+    Calculate the number of bars since the highest value of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the highest value
+    :return: The number of bars since the highest value of the source series
+    """
+    return highest(source, length, _bars=True)
+
+
+@overload
+def highestbars(length: int) -> PyneFloat:
+    return highest(high, length, _bars=True)
+
+
+def hma(source: float, length: int) -> PyneFloat:
+    """
+    Calculate the Hull Moving Average (HMA) of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the HMA
+    :return: The Hull Moving Average (HMA) of the source series
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    if (isinstance(source, NA) or source != source):
+        return na_float
+    length = int(length)
+
+    ma_np2 = wma(source, length // 2)
+    ma = wma(source, length)
+    if (isinstance(ma, NA) or ma != ma) or (isinstance(ma_np2, NA) or ma_np2 != ma_np2):
+        return na_float
+    return wma(2 * ma_np2 - ma, int(length ** 0.5))
+
+
+@module_property
+def iii() -> PyneFloat:
+    """
+    Intraday Intensity Index.
+
+    :return: Intraday Intensity Index
+    """
+    return (2 * close - high - low) / ((high - low) * volume)
+
+
+# noinspection PyPep8Naming
+def kc(series: float, length: int, mult: float | int, useTrueRange: bool = True) \
+        -> tuple[PyneFloat, PyneFloat, PyneFloat]:
+    """
+    Calculate the Keltner Channels (KC) of the source series with the given length and multiplier.
+
+    :param series: The source series
+    :param length: The length of the KC
+    :param mult: The multiplier of the KC
+    :param useTrueRange: Specifies whether to use True Range for KC calculation
+    :return: The Keltner Channels (KC) of the source series
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    assert mult > 0, "Invalid multiplier, multiplier must be greater than 0!"
+
+    base = ema(series, length)
+    span = tr(False) if useTrueRange else (high - low)
+    range_ma = ema(span, length)
+    if (isinstance(base, NA) or base != base):
+        return na_float, na_float, na_float
+    if (isinstance(range_ma, NA) or range_ma != range_ma):
+        return base, na_float, na_float
+    range_ma *= mult
+    return base, base + range_ma, base - range_ma
+
+
+# noinspection PyPep8Naming
+def kcw(series: float, length: int, mult: float | int, useTrueRange: bool = True) -> PyneFloat:
+    """
+    Calculate the Keltner Channels Width (KCW) of the source series with the given length and multiplier.
+
+    :param series: The source series
+    :param length: The length of the KCW
+    :param mult: The multiplier of the KCW
+    :param useTrueRange: Specifies whether to use True Range for KCW calculation
+    :return: The Keltner Channels Width (KCW) of the source series
+    """
+    b, h, l = kc(series, length, mult, useTrueRange)
+    if (isinstance(b, NA) or b != b) or b == 0.0:
+        return na_float
+    return (h - l) / b
+
+
+def linreg(source: Series[float], length: int, offset: int) -> PyneFloat:
+    """
+    Computes the linear regression value of the source series over a given period.
+
+    :param source: Input series
+    :param length: Number of bars to calculate regression
+    :param offset: Number of bars to shift the result
+    :return: Linear regression value
+    """
+    assert length > 0, "Invalid length, must be greater than 0!"
+    if length == 1:
+        return source
+    length = int(length)
+    window_size = length
+
+    # Precomputed constants for x-coordinates
+    sum_x = window_size * (window_size - 1) / 2.0
+    sum_x2 = (window_size - 1) * window_size * (2 * window_size - 1) / 6.0
+
+    # Persistent state variables
+    bar_count: Persistent[int] = 0
+    sum_y: Persistent[float] = 0.0  # Sum of source values in the window
+    sum_xy: Persistent[float] = 0.0  # Weighted sum: sum((window_size - 1 - i) * source[i])
+
+    if (isinstance(source, NA) or source != source):
+        if bar_count < window_size:
+            return na_float
+        # An NA bar leaves the window unchanged; fall through to report the held value
+    else:
+        # NA values are NOT stored in the buffer, only skipped, so ``src[window_size]``
+        # indexes past NA gaps to the true oldest value still inside the window.
+        # Reading the parameter directly would step back ``window_size`` *bars* and
+        # land inside an NA gap, subtracting an NA that poisons ``sum_y`` forever.
+        src: Series[float] = source
+
+        # Warm-up phase: accumulate values until the window is full
+        if bar_count < window_size:
+            prev_sum_y = sum_y
+            sum_y = prev_sum_y + source
+            sum_xy = (window_size - 1) * source + sum_xy - prev_sum_y
+            bar_count += 1
+
+            # Return NA until we have enough data
+            if bar_count < window_size:
+                return na_float
+        else:
+            # Rolling update: remove the oldest value when the window is full
+            dropped_value = src[window_size]
+            prev_sum_y = sum_y
+            sum_y = prev_sum_y + source - dropped_value
+            sum_xy = (window_size - 1) * source + sum_xy - prev_sum_y + dropped_value
+
+    # Compute slope and intercept
+    denominator = window_size * sum_x2 - sum_x * sum_x
+    slope = (window_size * sum_xy - sum_x * sum_y) / denominator
+    intercept = (sum_y - slope * sum_x) / window_size
+
+    # Compute final regression value
+    return intercept + slope * ((window_size - 1) - offset)
+
+
+# noinspection PyUnusedLocal,DuplicatedCode
+@overload
+def lowest(source: Series[float], length: int,
+           _bars: bool = False, _tuple: bool = False, _check_eq: bool = False) \
+        -> PyneFloat:
+    """
+    Calculate the lowest value of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the lowest value
+    :param _bars: If true, return the number of bars since the lowest value, internal use only
+    :param _tuple: If true, return a tuple of the lowest value and the number of bars since the lowest value,
+                   Internal use only
+    :param _check_eq: If true, check for equality too, internal use only
+    :return: The lowest value of the source series
+    """
+    last_min: Persistent[float] = na_float
+    last_min_index: Persistent[int] = 0
+
+    if last_min > source or (isinstance(last_min, NA) or last_min != last_min) or (_check_eq and last_min == source):
+        last_min = source
+        last_min_index = 0
+
+    if last_min_index >= length:
+        last_min = source
+        last_min_index = 0
+        for i in builtins.range(1, length):
+            s = source[i]
+            if s < last_min:
+                last_min = s
+                last_min_index = i
+            elif not _check_eq and s == last_min:
+                # For normal lowest: update index for equal values
+                last_min_index = i
+            # For pivot detection (_check_eq=True): don't update index for equal values
+
+    min_index = last_min_index
+    last_min_index += 1
+
+    if bar_index < length - 1:
+        return na_float if not _tuple else (na_float, NA(int))  # type: ignore[return-value]
+
+    if _bars:
+        return -min_index
+    if _tuple:
+        return last_min, -min_index  # type: ignore[return-value]
+    return last_min
+
+
+@overload
+def lowest(length: int) -> PyneFloat:
+    return lowest(low, length)
+
+
+# noinspection PyUnusedLocal
+@overload
+def lowestbars(source: Series[float], length: int) -> PyneFloat:
+    """
+    Calculate the number of bars since the lowest value of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the lowest value
+    :return: The number of bars since the lowest value of the source series
+    """
+    return lowest(source, length, _bars=True)
+
+
+@overload
+def lowestbars(length: int) -> PyneFloat:
+    return lowest(low, length, _bars=True)
+
+
+def macd(source: float, fastlen: int, slowlen: int, siglen: int) \
+        -> tuple[PyneFloat, PyneFloat, PyneFloat]:
+    """
+    Calculate the Moving Average Convergence Divergence (MACD) of the source series with the given
+    fast, slow, and signal lengths.
+
+    :param source: The source series
+    :param fastlen: The length of the fast EMA
+    :param slowlen: The length of the slow EMA
+    :param siglen: The length of the signal EMA
+    :return: Tuple of three MACD series:
+             - MACD Line
+             - Signal Line
+             - Histogram
+    """
+    assert fastlen > 0, "Invalid fast length, fast length must be greater than 0!"
+    assert slowlen > 0, "Invalid slow length, slow length must be greater than 0!"
+    assert siglen > 0, "Invalid signal length, signal length must be greater than 0!"
+    fast = ema(source, fastlen)
+    slow = ema(source, slowlen)
+    if (isinstance(fast, NA) or fast != fast) or (isinstance(slow, NA) or slow != slow):
+        return na_float, na_float, na_float
+    macd_val = fast - slow
+    signal = ema(macd_val, siglen)
+    if (isinstance(signal, NA) or signal != signal):
+        return macd_val, na_float, na_float
+    return macd_val, signal, macd_val - signal
+
+
+# noinspection PyShadowingBuiltins
+def max(source: Series[float]) -> PyneFloat:
+    """
+    Calculate the maximum value of the source series.
+
+    :param source: The source series
+    :return: The maximum value of the source series
+    """
+    max_val: Persistent[float] = na_float
+    if max_val < source or (isinstance(max_val, NA) or max_val != max_val):
+        max_val = source
+    return max_val
+
+
+def median(source: Series[TFI], length: int) -> TFI:
+    """
+    Calculate the median of the source series over a given period.
+
+    :param source: Input series of values
+    :param length: Number of bars to calculate over
+    :return: The median value or na during warmup
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    if length == 1:  # Shortcut
+        return source
+    length = int(length)
+
+    if (isinstance(source, NA) or source != source):
+        # type(source) would be the NA class itself — keep the source sentinel's type
+        return cast(TFI, source)
+
+    # Store heaps and window
+    heap_low: Persistent[list[TFI]] = []  # Max heap (negative values)
+    heap_high: Persistent[list[TFI]] = []  # Min heap
+    window: Persistent[list[TFI]] = []  # Recent values for removal
+
+    # Add new value and balance heaps
+    value = source
+    window.append(value)
+    heapq.heappush(heap_low, -value)
+    heapq.heappush(heap_high, -heapq.heappop(heap_low))
+
+    if len(heap_low) < len(heap_high):
+        heapq.heappush(heap_low, -heapq.heappop(heap_high))
+
+    # Remove old value if window full
+    if len(window) > length:
+        old = window.pop(0)
+
+        # Remove from correct heap
+        if old <= -heap_low[0]:
+            heap_low.remove(-old)
+            heapq.heapify(heap_low)
+        else:
+            heap_high.remove(old)
+            heapq.heapify(heap_high)
+
+        # Rebalance if needed
+        if len(heap_low) < len(heap_high):
+            heapq.heappush(heap_low, -heapq.heappop(heap_high))
+        elif len(heap_low) > len(heap_high) + 1:
+            heapq.heappush(heap_high, -heapq.heappop(heap_low))
+
+    # Return na during warmup
+    if len(window) < length:
+        return NA(cast(type[TFI], type(source)))  # type: ignore
+
+    # Return median based on heap sizes
+    if len(heap_low) > len(heap_high):
+        return -heap_low[0]  # Max heap root
+    return -heap_low[0] if isinstance(source, int) else (-heap_low[0] + heap_high[0]) / 2  # type: ignore
+
+
+def mfi(source: float, length: int) -> PyneFloat:
+    """
+    Calculate the Money Flow Index (MFI) of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the MFI
+    :return: The Money Flow Index (MFI) of the source series
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    if (isinstance(source, NA) or source != source):
+        return na_float
+    length = int(length)
+
+    chg = change(source)
+    upper = lib_math.sum(volume * (0.0 if not (isinstance(chg, NA) or chg != chg) and chg <= 0 else source), length)
+    lower = lib_math.sum(volume * (0.0 if not (isinstance(chg, NA) or chg != chg) and chg >= 0 else source), length)
+    if (isinstance(upper, NA) or upper != upper) or (isinstance(lower, NA) or lower != lower):
+        return na_float
+    return 100.0 - (100 * lower / (upper + lower))
+
+
+# noinspection PyShadowingBuiltins
+def min(source: Series[float]) -> PyneFloat:
+    """
+    Calculate the minimum value of the source series.
+
+    :param source: The source series
+    :return: The minimum value of the source series
+    """
+    min_val: Persistent[float] = na_float
+    if min_val > source or (isinstance(min_val, NA) or min_val != min_val):
+        min_val = source
+    return min_val
+
+
+def mode(source: Series[TFI], length: int) -> TFI:
+    """
+    Returns the mode of the series. If there are several values with the same frequency,
+    it returns the smallest value.
+
+    :param source: Series of values to process
+    :param length: Number of bars (length)
+    :return: The most frequently occurring value from the source. If none exists, returns
+             the smallest value instead. Returns na during warm-up period.
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    if (isinstance(source, NA) or source != source):
+        return cast(TFI, source)
+    if bar_index < length - 1:
+        return cast(TFI, NA(builtins.type(source)))
+    length = int(length)
+
+    # Store values for quick access
+    values = [source[i] for i in builtins.range(length) if not (isinstance(source[i], NA) or source[i] != source[i])]
+    if not values:
+        return cast(TFI, NA(builtins.type(source)))
+
+    # Find mode - sort values to handle equal frequencies
+    values.sort()  # Ensure we pick the smallest value when frequencies are equal
+    mode_val = values[0]
+    current_val = values[0]
+    max_freq = curr_freq = 1
+
+    # Single pass through sorted values
+    for i in builtins.range(1, len(values)):
+        if values[i] == current_val:
+            curr_freq += 1
+            if curr_freq > max_freq:
+                max_freq = curr_freq
+                mode_val = current_val
+        else:
+            current_val = values[i]
+            curr_freq = 1
+
+    return mode_val
+
+
+def mom(source: float, length: int) -> PyneFloat:
+    """
+    Calculate the Momentum of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the Momentum
+    :return: The Momentum of the source series
+    """
+    # It is exactly the same as change function
+    return change(source, length)
+
+
+# noinspection PyUnusedLocal
+@module_property
+def nvi() -> PyneFloat:
+    """
+    Negative Volume Index.
+
+    :return: Negative Volume Index
+    """
+    prev_close: Persistent[float] = 0.0
+    prev_volume: Persistent[float] = 0.0
+    prev_nvi: Persistent[float] = 1.0
+
+    if close == 0.0 or prev_close == 0.0:
+        _nvi = prev_nvi
+    else:
+        _nvi = prev_nvi + ((close - prev_close) / prev_close) * prev_nvi if volume < prev_volume else prev_nvi
+
+    prev_close = close
+    prev_volume = volume
+    prev_nvi = _nvi
+
+    return _nvi
+
+
+@module_property
+def obv() -> PyneFloat:
+    """
+    On Balance Volume.
+
+    :return: On Balance Volume
+    """
+    chg = change(close)
+    if (isinstance(chg, NA) or chg != chg):
+        return na_float
+    if chg > 0:
+        chg = 1.0
+    elif chg < 0:
+        chg = -1.0
+    else:
+        chg = 0.0
+    return cum(volume * chg)
+
+
+def percentile_linear_interpolation(source: Series[float], length: int, percentage: int | float) \
+        -> PyneFloat:
+    """
+    Calculates percentile using method of linear interpolation between the two nearest ranks.
+
+    :param source: The source series
+    :param length: The length of the percentile
+    :param percentage: The percentage of the percentile
+    :return: The percentile of the source series
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    length = int(length)
+    # The final slice reads ``length`` candles of history; grow the source
+    # buffer to fit it (the per-series default may be smaller). Done before the
+    # warmup guard so the oldest candles are kept from the first bar on.
+    max_bars_back(source, length)
+    if (isinstance(source, NA) or source != source):
+        return na_float
+
+    if bar_index < length - 1:
+        return na_float
+
+    return array.percentile_linear_interpolation(source[:length], percentage)  # type: ignore
+
+
+def percentile_nearest_rank(source: Series[float], length: int, percentage: int | float) \
+        -> PyneFloat:
+    """
+    Calculates percentile using the nearest rank method.
+
+    :param source: The source series
+    :param length: The length of the percentile
+    :param percentage: The percentage of the percentile
+    :return: The percentile of the source series
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    length = int(length)
+    # The final slice reads ``length`` candles of history; grow the source
+    # buffer to fit it (the per-series default may be smaller). Done before the
+    # warmup guard so the oldest candles are kept from the first bar on.
+    max_bars_back(source, length)
+    if (isinstance(source, NA) or source != source):
+        return na_float
+
+    if bar_index < length - 1:
+        return na_float
+
+    return array.percentile_nearest_rank(source[:length], percentage)  # type: ignore
+
+
+def percentrank(source: Series[float], length: int) -> PyneFloat:
+    """
+    Percent rank is the percents of how many previous values was less than or equal to the current
+    value of given series.
+
+    :param source: The source series
+    :param length: Number of bars back to include in the calculation
+    :return: The percentage of values less than or equal to the current value
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    length = int(length)
+    # The final slice reads ``length + 1`` candles of history; a buffer of
+    # ``max_bars_back == length`` (capacity ``length + 1``) holds exactly that.
+    # Done before the warmup guard so the oldest candles are kept from bar 0.
+    max_bars_back(source, length)
+    if (isinstance(source, NA) or source != source):
+        return na_float
+
+    if bar_index < length:
+        return na_float
+
+    return array.percentrank(source[:length + 1], 0)  # type: ignore
+
+
+# noinspection PyUnusedLocal,PyShadowingBuiltins
+def pivot_point_levels(type: str, anchor: bool, developing: bool = False) -> list[PyneFloat]:
+    """
+    Calculate pivot point levels based on the specified calculation type.
+
+    Returns an array of 11 float values representing pivot point levels:
+    [P, R1, S1, R2, S2, R3, S3, R4, S4, R5, S5]
+
+    :param type: Pivot calculation type: "Traditional", "Fibonacci", "Woodie",
+                 "Classic", "DM", or "Camarilla"
+    :param anchor: Condition that triggers recalculation of pivot levels
+                   (e.g., timeframe.change("D"))
+    :param developing: If true, values recalculate on each bar using current OHLC;
+                      if false (default), values remain constant until the next anchor
+    :return: Array of 11 float values: [P, R1, S1, R2, S2, R3, S3, R4, S4, R5, S5]
+             Not all types support all levels - unsupported ones return na_float
+    """
+    # Persistent state for anchor-based calculation
+    # These store the COMPLETED previous period's values (used when developing=False)
+    prev_period_high: Persistent[float] = na_float
+    prev_period_low: Persistent[float] = na_float
+    prev_period_close: Persistent[float] = na_float
+    prev_period_open: Persistent[float] = na_float
+
+    # These accumulate values for the CURRENT period (will become prev_period on next anchor)
+    curr_period_high: Persistent[float] = na_float
+    curr_period_low: Persistent[float] = na_float
+    curr_period_open: Persistent[float] = na_float
+    is_first_bar_of_period: Persistent[bool] = True
+
+    levels: Persistent[list[PyneFloat]] = [na_float] * 11
+    had_anchor: Persistent[bool] = False
+
+    # Normalize type to lowercase for case-insensitive comparison
+    type_lower = type.lower() if isinstance(type, str) else ""
+
+    # On anchor, finalize the previous period and start a new one
+    if anchor:
+        # Save the accumulated current period values as the previous period
+        prev_period_high = curr_period_high
+        prev_period_low = curr_period_low
+        prev_period_close = close[1] if bar_index > 0 else close  # Last close of prev period
+        prev_period_open = curr_period_open
+
+        # Reset current period accumulators for the new period
+        curr_period_high = high
+        curr_period_low = low
+        curr_period_open = open
+        is_first_bar_of_period = False
+        had_anchor = True
+    else:
+        # Accumulate OHLC extremes for current period
+        if is_first_bar_of_period or (isinstance(curr_period_high, NA) or curr_period_high != curr_period_high):
+            curr_period_high = high
+            curr_period_low = low
+            curr_period_open = open
+            is_first_bar_of_period = False
+        else:
+            if not (isinstance(high, NA) or high != high) and high > curr_period_high:
+                curr_period_high = high
+            if not (isinstance(low, NA) or low != low) and low < curr_period_low:
+                curr_period_low = low
+
+    # If no anchor has occurred yet, return all NA values
+    if not had_anchor:
+        return [na_float] * 11
+
+    # Determine which OHLC values to use
+    if developing:
+        # Use current accumulated values for developing mode
+        h = curr_period_high
+        l = curr_period_low
+        c = close  # Current close for developing
+        o = curr_period_open
+    else:
+        # Use previous period's OHLC (fixed after anchor)
+        h = prev_period_high
+        l = prev_period_low
+        c = prev_period_close
+        o = prev_period_open
+
+    # Check for NA values
+    if (isinstance(h, NA) or h != h) or (isinstance(l, NA) or l != l) or (isinstance(c, NA) or c != c):
+        return [na_float] * 11
+
+    # Calculate range
+    rng = h - l
+
+    # Calculate levels based on type
+    if type_lower in ("traditional", "classic"):
+        # Traditional/Classic Pivot Points
+        p = (h + l + c) / 3
+        r1 = 2 * p - l
+        s1 = 2 * p - h
+        r2 = p + rng
+        s2 = p - rng
+        r3 = r1 + rng
+        s3 = s1 - rng
+        levels = [p, r1, s1, r2, s2, r3, s3, na_float, na_float, na_float, na_float]
+
+    elif type_lower == "fibonacci":
+        # Fibonacci Pivot Points
+        p = (h + l + c) / 3
+        r1 = p + 0.382 * rng
+        s1 = p - 0.382 * rng
+        r2 = p + 0.618 * rng
+        s2 = p - 0.618 * rng
+        r3 = p + 1.000 * rng
+        s3 = p - 1.000 * rng
+        levels = [p, r1, s1, r2, s2, r3, s3, na_float, na_float, na_float, na_float]
+
+    elif type_lower == "woodie":
+        # Woodie Pivot Points
+        # Note: Woodie uses current period's OPEN (not prev period's close) for the "close" component
+        # This makes Woodie more responsive to current price action
+        woodie_c = curr_period_open if not developing else close
+        if (isinstance(woodie_c, NA) or woodie_c != woodie_c):
+            return [na_float] * 11
+        p = (h + l + 2 * woodie_c) / 4
+        r1 = 2 * p - l
+        s1 = 2 * p - h
+        r2 = p + rng
+        s2 = p - rng
+        r3 = r1 + rng
+        s3 = s1 - rng
+        levels = [p, r1, s1, r2, s2, r3, s3, na_float, na_float, na_float, na_float]
+
+    elif type_lower == "dm":
+        # DeMark Pivot Points
+        if (isinstance(o, NA) or o != o):
+            return [na_float] * 11
+
+        if c < o:
+            x = h + 2 * l + c
+        elif c > o:
+            x = 2 * h + l + c
+        else:  # c == o
+            x = h + l + 2 * c
+
+        p = x / 4
+        r1 = x / 2 - l
+        s1 = x / 2 - h
+        # DM only has P, R1, S1
+        levels = [p, r1, s1, na_float, na_float, na_float, na_float,
+                  na_float, na_float, na_float, na_float]
+
+    elif type_lower == "camarilla":
+        # Camarilla Pivot Points
+        p = (h + l + c) / 3
+        r1 = c + rng * 1.1 / 12
+        s1 = c - rng * 1.1 / 12
+        r2 = c + rng * 1.1 / 6
+        s2 = c - rng * 1.1 / 6
+        r3 = c + rng * 1.1 / 4
+        s3 = c - rng * 1.1 / 4
+        r4 = c + rng * 1.1 / 2
+        s4 = c - rng * 1.1 / 2
+        # Camarilla has P, R1-R4, S1-S4 (no R5, S5)
+        levels = [p, r1, s1, r2, s2, r3, s3, r4, s4, na_float, na_float]
+
+    else:
+        # Unknown type - return all NA
+        levels = [na_float] * 11
+
+    return levels
+
+
+@overload
+def pivothigh(source: float, leftbars: int, rightbars: int) -> PyneFloat:
+    """
+    This function returns price of the pivot high point. It returns 'NaN', if there was no pivot high point.
+
+    :param source: The source series
+    :param leftbars: Left strength
+    :param rightbars: Right strength.
+    :return: Price of the pivot high point, or NaN if no pivot
+    """
+    assert leftbars > 0, "Invalid leftbars, leftbars must be greater than 0!"
+    assert rightbars > 0, "Invalid rightbars, rightbars must be greater than 0!"
+
+    if (isinstance(source, NA) or source != source):
+        return na_float
+
+    pivotrange = leftbars + rightbars + 1
+    ph, pi = cast(tuple[float, int], highest(source, pivotrange, _tuple=True, _check_eq=True))
+
+    if pi == -rightbars:
+        return ph
+
+    return na_float
+
+
+@overload
+def pivothigh(leftbars: int, rightbars: int) -> PyneFloat:
+    """
+    This function returns price of the pivot high point. It returns 'NaN', if there was no pivot high point.
+
+    :param leftbars: Left strength
+    :param rightbars: Right strength.
+    :return: Price of the pivot high point, or NaN if no pivot
+    """
+    try:
+        return pivothigh(safe_convert.safe_float(high), leftbars, rightbars)  # type: ignore
+    except TypeError:
+        if (isinstance(high, NA) or high != high):
+            return na_float
+        else:
+            raise
+
+
+@overload
+def pivotlow(source: float, leftbars: int, rightbars: int) -> PyneFloat:
+    """
+    This function returns price of the pivot low point. It returns 'NaN', if there was no pivot low point.
+
+    :param source: The source series
+    :param leftbars: Left strength
+    :param rightbars: Right strength.
+    :return: Price of the pivot low point, or NaN if no pivot
+    """
+    assert leftbars > 0, "Invalid leftbars, leftbars must be greater than 0!"
+    assert rightbars > 0, "Invalid rightbars, rightbars must be greater than 0!"
+
+    if (isinstance(source, NA) or source != source):
+        return na_float
+
+    pivotrange = leftbars + rightbars + 1
+    pl, pi = cast(tuple[float, int], lowest(source, pivotrange, _tuple=True, _check_eq=True))
+    if pi == -rightbars:
+        return pl
+
+    return na_float
+
+
+@overload
+def pivotlow(leftbars: int, rightbars: int) -> PyneFloat:
+    """
+    This function returns price of the pivot low point. It returns 'NaN', if there was no pivot low point.
+
+    :param leftbars: Left strength
+    :param rightbars: Right strength.
+    :return: Price of the pivot low point, or NaN if no pivot
+    """
+    try:
+        return pivotlow(safe_convert.safe_float(low), leftbars, rightbars)  # type: ignore
+    except TypeError:
+        if (isinstance(low, NA) or low != low):
+            return na_float
+        else:
+            raise
+
+
+# noinspection PyUnusedLocal
+@module_property
+def pvi() -> PyneFloat:
+    """
+    Positive Volume Index.
+
+    :return: Positive Volume Index
+    """
+    prev_close: Persistent[float] = 0.0
+    prev_volume: Persistent[float] = 0.0
+    prev_pvi: Persistent[float] = 1.0
+
+    _pvi = prev_pvi + ((close - prev_close) / prev_close) * prev_pvi if volume > prev_volume else prev_pvi
+    # na() predicate semantics: a division by zero (prev_close warmup 0.0) gives
+    # inf, which is na on TV — not just nan, so the guard must be isfinite-based.
+    if isinstance(_pvi, NA) or not math.isfinite(_pvi):
+        _pvi = prev_pvi
+
+    prev_close = close
+    prev_volume = volume
+    prev_pvi = _pvi
+
+    return _pvi
+
+
+# noinspection PyUnusedLocal
+@module_property
+def pvt() -> PyneFloat:
+    """
+    Price Volume Trend.
+
+    :return: Price Volume Trend
+    """
+    prev_close: Persistent[float] = na_float
+    chg = close - prev_close
+    res = cum((chg / prev_close) * volume)
+    prev_close = close
+    return res
+
+
+# noinspection PyShadowingBuiltins
+def range(source: Series[float], length: int) -> PyneFloat:
+    """
+    Returns the difference between the max and min values in a series.
+
+    :param source: The source series
+    :param length: Number of bars
+    :return: The range of the source series
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    if (isinstance(source, NA) or source != source):
+        return na_float
+    length = int(length)
+
+    return highest(source, length) - lowest(source, length)
+
+
+def rci(source: Series[float], length: int) -> PyneFloat:
+    """
+    Calculate Rank Correlation Index (RCI).
+
+    :param source: Series of values to calculate RCI for
+    :param length: Length of RCI calculation period
+    :return: RCI value between -100 and 100, or na during warmup
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    length = int(length)
+    # The slice below reads ``length`` candles of history; grow the source
+    # buffer to fit it (the per-series default may be smaller). Done before the
+    # warmup guard so the oldest candles are kept from the first bar on.
+    max_bars_back(source, length)
+    if (isinstance(source, NA) or source != source):
+        return na_float
+
+    if bar_index < length:
+        return na_float
+
+    # Collect values for performance
+    values = cast(list[float], source[:length])  # type: ignore
+
+    # Calculate sums for correlation
+    sum_x = sum_y = sum_xy = sum_x2 = sum_y2 = 0.0
+
+    for i in builtins.range(length):
+        x = i + 1  # Time rank (newest value gets highest rank)
+        y = _avgrank(values, values[i])  # Data rank  # type: ignore
+
+        sum_x += x
+        sum_y += y
+        sum_xy += x * y
+        sum_x2 += x * x
+        sum_y2 += y * y
+
+    # Calculate correlation coefficient
+    n = length
+    numerator = n * sum_xy - sum_x * sum_y
+    denominator = math.sqrt((n * sum_x2 - sum_x * sum_x) * (n * sum_y2 - sum_y * sum_y))
+    # Divide first, then scale by 100. TradingView computes rci in this exact
+    # (num / den) * 100 order, floating-point rounding and all, so this form
+    # reproduces its output. The mathematically "correctly rounded" alternative
+    # num * 100 / den lands 1 ULP off at near-tie bars and diverges from TV: on
+    # the wild RCI-strategy reference (BINANCE:BTCUSDT 30m) it raised the
+    # extra/missing entry divergence from 14/6 to 30/11. Verified — do not reorder.
+    return (numerator / denominator) * 100
+
+
+# noinspection PyUnusedLocal
+def rising(source: float, length: int) -> bool:
+    """
+    Test if the source series is now rising for length bars long.
+
+    :param source: The source series
+    :param length: The length of the rising test
+    :return: True if the source series is rising for length bars long
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    length = int(length)
+
+    last_val: Persistent[float] = na_float
+    counter: Persistent[int] = 0
+
+    if (isinstance(last_val, NA) or last_val != last_val):
+        last_val = source
+        return False
+
+    if source > last_val:
+        counter += 1
+    else:
+        counter = 0
+
+    last_val = source
+    return counter >= length
+
+
+def rma(source: PyneFloat, length: int) -> PyneFloat:
+    """
+    Calculate the RMA (Running Moving Average) of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the RMA
+    :return: The RMA of the source series
+    """
+    return ema(source, length, 1 / length)
+
+
+def roc(source: Series[float], length: int) -> PyneFloat:
+    """
+    Calculate the Rate of Change (ROC) of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the ROC
+    :return: The Rate of Change (ROC) of the source series
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    if (isinstance(source, NA) or source != source):
+        return na_float
+    length = int(length)
+    # Grow the buffer so ``source[length]`` stays addressable for lengths beyond the
+    # per-series default max_bars_back (500); otherwise it reads na and the roc is na.
+    max_bars_back(source, length)
+
+    prev_val = source[length]
+    chg = change(source, length)
+
+    if (isinstance(prev_val, NA) or prev_val != prev_val):
+        return na_float
+
+    return 100 * chg / prev_val
+
+
+# noinspection PyUnusedLocal
+def rsi(source: float, length: int) -> PyneFloat:
+    """
+    Calculate the Relative Strength Index (RSI) of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the RSI
+    :return: The Relative Strength Index (RSI) of the source series
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    if (isinstance(source, NA) or source != source):
+        return na_float
+
+    prev_src: Persistent[float] = na_float
+    if (isinstance(prev_src, NA) or prev_src != prev_src):
+        prev_src = source
+        return na_float
+
+    rma_u = rma(builtins.max(source - prev_src, 0.0), length)
+    rma_d = rma(builtins.max(prev_src - source, 0.0), length)
+    prev_src = source
+
+    return 100 - 100 / (1 + rma_u / rma_d)
+
+
+# noinspection PyShadowingBuiltins,PyUnusedLocal,PyShadowingNames
+def sar(start: float = 0.02, inc: float = 0.02, max: float = 0.2) -> PyneFloat:
+    """
+    Parabolic SAR (Stop and Reverse) - method devised by J. Welles Wilder, Jr.,
+    to find potential reversals in the market price direction of traded goods.
+
+    :param start: Starting value for acceleration factor
+    :param inc: Acceleration factor increment
+    :param max: Maximum acceleration factor value
+    :return: SAR value for current bar
+    """
+    assert 0 < start <= max, "Start must be positive and not greater than max!"
+    assert inc > 0, "Increment must be positive!"
+    assert max <= 0.5, "Maximum cannot exceed 0.5!"
+
+    if bar_index == 0:
+        return na_float
+
+    # Persistent states
+    pos_long: Persistent[bool] = True  # Current position (long/short)
+    af: Persistent[float] = start  # Current acceleration factor
+    sar_val: Persistent[float] = na_float  # Current SAR value
+    ep: Persistent[float] = na_float  # Extreme point
+
+    # Initialize on second bar
+    if bar_index == 1:
+        if high[1] > high:
+            pos_long = False
+            sar_val = high[1]  # short start
+            ep = low  # EP is current low
+        else:
+            pos_long = True
+            sar_val = low[1]  # long start
+            ep = high  # EP is current high
+        return sar_val
+
+    # Calculate next SAR value
+    next_sar = sar_val + af * (ep - sar_val)
+
+    # Trend-dependent logic
+    if pos_long:
+        # Long trend
+        if low <= next_sar:  # Reverse to short
+            pos_long = False
+            af = start
+            next_sar = ep  # Start from previous EP (Wilder method)
+            # Clip to current and previous 2 candle highs
+            next_sar = builtins.max(
+                next_sar,
+                high,
+                high[1],
+                high[2] if not (isinstance(high[2], NA) or high[2] != high[2]) else high[1]
+            )
+            ep = low  # New EP
+        else:
+            # Continue long
+            next_sar = builtins.min(
+                next_sar,
+                low[1],
+                low[2] if not (isinstance(low[2], NA) or low[2] != low[2]) else low[1]
+            )
+            if high > ep:  # New peak
+                ep = high
+                af = builtins.min(af + inc, max)
+    else:
+        # Short trend
+        if high >= next_sar:  # Reverse to long
+            pos_long = True
+            af = start
+            next_sar = ep  # Start from previous EP (Wilder method)
+            # Clip to current and previous 2 candle lows
+            next_sar = builtins.min(
+                next_sar,
+                low,
+                low[1],
+                low[2] if not (isinstance(low[2], NA) or low[2] != low[2]) else low[1]
+            )
+            ep = high  # New EP
+        else:
+            # Continue short
+            next_sar = builtins.max(
+                next_sar,
+                high[1],
+                high[2] if not (isinstance(high[2], NA) or high[2] != high[2]) else high[1]
+            )
+            if low < ep:  # New trough
+                ep = low
+                af = builtins.min(af + inc, max)
+
+    sar_val = next_sar
+    return sar_val
+
+
+def sma(source: Series[float], length: int) -> PyneFloat:
+    """
+    Calculate Simple Moving Average (SMA)
+
+    :param source: The source series
+    :param length: The length of the moving average
+    :return: The Simple Moving Average (SMA)
+    """
+    # Round is necessary to solve precision issues
+    return round(lib_math.sum(source, length) / length, 15)
+
+
+def stdev(source: float, length: int, biased=True) -> PyneFloat:
+    """
+    Calculate the standard deviation of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the standard deviation
+    :param biased: Specifies whether the biased or unbiased standard deviation is calculated
+    :return: The standard deviation of the source series
+    """
+    try:
+        return math.sqrt(variance(source, length, biased))
+    except TypeError:
+        return na_float
+
+
+# noinspection PyShadowingNames
+def stoch(source: float | Series[float], high: float | Series[float], low: float | Series[float],
+          length: int) -> PyneFloat:
+    """
+    Calculate the Stochastic Oscillator of the source series with the given length.
+
+    :param source: The source series
+    :param high: Series of high values
+    :param low: Series of low values
+    :param length: The length of the Stochastic Oscillator
+    :return: The Stochastic Oscillator of the source series
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    if (isinstance(source, NA) or source != source) or (isinstance(high, NA) or high != high) or (isinstance(low, NA) or low != low):
+        return na_float
+    length = int(length)
+
+    highs: Series[float] = high
+    lows: Series[float] = low
+    hmax = highest(highs, length)
+    lmin = lowest(lows, length)
+
+    if bar_index < length - 1:
+        return na_float
+
+    dl_diff = source - lmin
+    hl_diff = hmax - lmin
+    if dl_diff < 0.0:
+        k = 0.0
+    else:
+        k = 100 * dl_diff / hl_diff
+        k = 100.0 if k > 100.0 else 0.0 if k < 0.0 else k
+    return k  # type: ignore
+
+
+# noinspection PyUnusedLocal,PyShadowingNames
+def supertrend(factor: float | int, atr_period: int) -> tuple[PyneFloat, PyneInt]:
+    """
+    Calculate Supertrend indicator.
+
+    :param factor: ATR multiplier
+    :param atr_period: ATR period length
+    :return: Tuple of (supertrend value, direction). Direction: 1=down, -1=up
+    """
+    assert atr_period > 0, "Invalid ATR period, must be greater than 0!"
+
+    # Store persistent state
+    prev_lower: Persistent[float] = na_float
+    prev_upper: Persistent[float] = na_float
+    prev_close: Persistent[float] = na_float
+    prev_direction: Persistent[int] = NA(int)
+    prev_supertrend: Persistent[float] = na_float
+
+    # Calculate base values
+    src = hl2
+    atr_val = atr(atr_period)
+
+    # This is a strange bug in Pine Script, but we need to replicate it
+    if bar_index == 0:
+        return 0.0, 1
+
+    if (isinstance(src, NA) or src != src) or (isinstance(atr_val, NA) or atr_val != atr_val):
+        return na_float, prev_direction if not (isinstance(prev_direction, NA) or prev_direction != prev_direction) else 1
+
+    # Calculate bands
+    upper = src + factor * atr_val
+    lower = src - factor * atr_val
+
+    # First value initialization
+    if (isinstance(prev_direction, NA) or prev_direction != prev_direction):
+        direction = 1
+        supertrend = upper
+        prev_direction = direction
+        prev_supertrend = supertrend
+        prev_lower = lower
+        prev_upper = upper
+        prev_close = close
+        return supertrend, direction
+
+    # Adjust bands based on previous values
+    if lower > prev_lower or prev_close < prev_lower:
+        curr_lower = lower
+    else:
+        curr_lower = prev_lower
+
+    if upper < prev_upper or prev_close > prev_upper:
+        curr_upper = upper
+    else:
+        curr_upper = prev_upper
+
+    # Calculate direction
+    if prev_supertrend == prev_upper:
+        direction = -1 if close > curr_upper else 1
+    else:
+        direction = 1 if close < curr_lower else -1
+
+    # Calculate supertrend value
+    supertrend = curr_upper if direction == 1 else curr_lower
+
+    # Store values for next iteration
+    prev_direction = direction
+    prev_supertrend = supertrend
+    prev_lower = curr_lower
+    prev_upper = curr_upper
+    prev_close = close
+
+    return supertrend, direction
+
+
+def swma(source: Series[float]) -> PyneFloat:
+    """
+    Symmetrically weighted moving average with fixed length: 4. Weights: [1/6, 2/6, 2/6, 1/6].
+
+    :param source: The source series
+    :return: The SWWMA of the source series
+    """
+    if (isinstance(source, NA) or source != source):
+        return na_float
+
+    return (source + 2 * source[1] + 2 * source[2] + source[3]) / 6
+
+
+# noinspection PyUnusedLocal
+@module_function_property
+def tr(handle_na: bool = False) -> PyneFloat:
+    """
+    Calculate True Range (TR)
+
+    :param handle_na: If true, and previous day's close is NaN then tr would be calculated as
+                      current day high-low. Otherwise (if false) tr would return NaN in such cases
+    :return: True Range (TR)
+    """
+    prev_close: Persistent[float] = na_float
+
+    if (isinstance(prev_close, NA) or prev_close != prev_close):
+        val = (high - low) if handle_na else na_float
+    else:
+        val = builtins.max(high - low, abs(high - prev_close), abs(low - prev_close))
+
+    prev_close = close
+    return val  # type: ignore
+
+
+def tsi(source: Series[float], short_length: int, long_length: int) -> PyneFloat:
+    """
+    True strength index. It uses moving averages of the underlying momentum
+    of a financial instrument.
+
+    :param source: Source series
+    :param short_length: Short length
+    :param long_length: Long length
+    :return: True strength index between -1 and 1
+    """
+    assert short_length > 0, "Invalid short length, must be greater than 0!"
+    assert long_length > 0, "Invalid long length, must be greater than 0!"
+    if (isinstance(source, NA) or source != source):
+        return na_float
+
+    # Calculate momentum
+    momentum = change(source)
+    if (isinstance(momentum, NA) or momentum != momentum):
+        return na_float
+
+    # First smooth both momentum and abs(momentum)
+    momentum_ema = ema(momentum, long_length)
+    abs_momentum_ema = ema(abs(momentum), long_length)
+
+    if (isinstance(momentum_ema, NA) or momentum_ema != momentum_ema) or (isinstance(abs_momentum_ema, NA) or abs_momentum_ema != abs_momentum_ema):
+        return na_float
+
+    # Second smooth
+    tsi_value = ema(momentum_ema, short_length)
+    abs_value = ema(abs_momentum_ema, short_length)
+
+    if (isinstance(abs_value, NA) or abs_value != abs_value):
+        return na_float
+
+    return tsi_value / abs_value
+
+
+def variance(source: Series[float],
+             length: int,
+             biased: bool = True) -> PyneFloat:
+    """
+    Calculate the rolling variance of the source series.
+
+    :param source: The source series.
+    :param length: The length of the rolling window.
+    :param biased: If True, calculates biased variance; otherwise, calculates unbiased variance.
+    :return: The variance of the source series.
+    """
+    assert length > 0, "Invalid length, must be > 0!"
+    length = int(length)
+    if length == 1:
+        return 0.0
+    # Grow the buffer so the decremental read ``source[length]`` stays addressable for
+    # lengths beyond the per-series default max_bars_back (500); otherwise it reads na and
+    # poisons the Welford accumulators permanently (feeds stdev/bb/bbw/kc). Runs before the
+    # na guard so the buffer keeps growing on na bars too, ahead of any wrap.
+    max_bars_back(source, length)
+    if (isinstance(source, NA) or source != source):
+        return na_float
+
+    # Welford online recurrence with Pébay (2008) decremental step for sliding
+    # window. Avoids the catastrophic cancellation of the textbook
+    # `E[X²] - E[X]²` form by accumulating m2 (sum of squared deviations from
+    # the running mean) directly. Kahan compensation on `mean` and `m2`
+    # eliminates ULP-level drift across long add/remove sequences. The final
+    # `max(0.0, ...)` is a safety clamp for the rare case where decremental
+    # round-off lands one ULP below zero — `stdev()` calls `math.sqrt(var)`
+    # and would crash on a negative argument.
+    count: Persistent[int] = 0
+    mu: Persistent[float] = 0.0
+    mu_c: Persistent[float] = 0.0
+    m2: Persistent[float] = 0.0
+    m2_c: Persistent[float] = 0.0
+
+    # Add new sample (Welford incremental)
+    if count < length:
+        count += 1
+        n_after = count
+    else:
+        count += 1
+        n_after = length + 1  # transient: post-add, pre-remove
+
+    delta = source - mu
+    inc = delta / n_after
+    y = inc - mu_c
+    t = mu + y
+    mu_c = (t - mu) - y  # noqa - it is persistent
+    mu = t
+    m2_inc = delta * (source - mu)
+    y = m2_inc - m2_c
+    t = m2 + y
+    m2_c = (t - m2) - y  # noqa - it is persistent
+    m2 = t
+
+    if count < length:
+        return na_float
+
+    if count > length:
+        # Remove oldest sample (Welford decremental, Pébay 2008)
+        old_value = source[length]
+        delta = old_value - mu
+        dec = -delta / length
+        y = dec - mu_c
+        t = mu + y
+        mu_c = (t - mu) - y  # noqa - it is persistent
+        mu = t
+        m2_dec = -delta * (old_value - mu)
+        y = m2_dec - m2_c
+        t = m2 + y
+        m2_c = (t - m2) - y  # noqa - it is persistent
+        m2 = t
+
+    if biased:
+        var = m2 / length
+    else:
+        var = m2 / (length - 1)
+    # Safety clamp: decremental round-off can occasionally land 1 ULP below
+    # zero on long constant runs; stdev() would crash inside math.sqrt().
+    return builtins.max(0.0, var)
+
+
+def valuewhen(condition: bool, source: float, occurrence: int) -> PyneFloat:
+    """
+    Returns the value of the source series when the condition is true for the given occurrence.
+
+    :param condition: The condition series
+    :param source: The source series
+    :param occurrence: The occurrence of the condition
+    :return: The value of the source series when the condition is true for the given occurrence
+    """
+    assert occurrence >= 0, "Invalid occurrence, must be >= 0!"
+    if (isinstance(source, NA) or source != source):
+        return na_float
+
+    values: Persistent[deque[float]] = deque(maxlen=occurrence + 1)
+
+    if condition:
+        values.append(source)
+
+    if len(values) == occurrence + 1:
+        return values[0]
+    return na_float
+
+
+# noinspection PyUnusedLocal
+@module_function_property
+def vwap(source: Series[float] | None = None, anchor: bool | None = None,
+         stdev_mult: float | None = None) -> PyneFloat | tuple[PyneFloat, PyneFloat, PyneFloat]:
+    """
+    Volume weighted average price.
+
+    Referenced bare (``ta.vwap``) this is the Pine built-in variable: the VWAP of
+    ``hlc3`` anchored to the session. Passing an explicit ``source`` selects the
+    function form ``ta.vwap(source)``.
+
+    :param source: The source series; defaults to ``hlc3`` for the bare variable form
+    :param anchor: The condition that triggers the reset of VWAP calculation
+    :param stdev_mult: If specified, the function will calculate the standard deviation bands based on the main VWAP
+    :return: The VWAP value or tuple of (vwap, upper_band, lower_band) if stdev_mult is specified
+    """
+    if source is None:
+        source = hlc3
+    if (isinstance(source, NA) or source != source):
+        return na_float if stdev_mult is None else (na_float, na_float, na_float)
+
+    # Persistent variables for calculation
+    sum_vol: Persistent[float] = 0.0
+    sum_pv: Persistent[float] = 0.0
+    sum_ppv: Persistent[float] = 0.0
+    had_anchor: Persistent[bool] = False
+
+    if anchor is None:
+        anchor = session.isfirstbar
+
+    # Reset calculations if anchor condition is met
+    if anchor is not None and anchor:
+        sum_vol = volume
+        sum_pv = source * volume
+        sum_ppv = 0.0
+        had_anchor = True
+    # Only accumulate after first anchor
+    elif had_anchor:
+        sum_vol += volume
+        sum_pv += source * volume
+    else:  # There was no anchor yet
+        return na_float if stdev_mult is None else (na_float, na_float, na_float)
+
+    # Calculate VWAP
+    vwap_value = sum_pv / sum_vol
+    if (isinstance(vwap_value, NA) or vwap_value != vwap_value):
+        return na_float if stdev_mult is None else (na_float, na_float, na_float)
+
+    # If stdev_mult is specified, calculate bands
+    if had_anchor and stdev_mult is not None:
+        sum_ppv += source * source * volume
+        std = math.sqrt(builtins.max(0.0, sum_ppv / sum_vol - vwap_value * vwap_value))
+        band_width = std * stdev_mult
+        # Return tuple of (vwap, upper_band, lower_band)
+        return vwap_value, vwap_value + band_width, vwap_value - band_width
+
+    return vwap_value
+
+
+def vwma(source: float, length: int) -> PyneFloat:
+    return sma(source * volume, length) / sma(volume, length)
+
+
+# noinspection PyUnusedLocal
+@module_property
+def wad() -> PyneFloat:
+    """
+    Williams Accumulation/Distribution.
+
+    :return: Williams Accumulation/Distribution
+    """
+    prev_close: Persistent[float] = na_float
+    true_high = builtins.max(high, prev_close)
+    true_low = builtins.min(low, prev_close)
+    momentum = close - prev_close
+    gain = (close - true_low) if momentum > 0.0 else ((close - true_high) if momentum < 0.0 else 0.0)
+    prev_close = close
+    return cum(gain)
+
+
+def wma(source: Series[float], length: int) -> PyneFloat:
+    """
+    Calculate the Weighted Moving Average (WMA) of the source series with the given length.
+
+    :param source: The source series
+    :param length: The length of the WMA
+    :return: The WMA of the source series
+    """
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    length = int(length)
+
+    # Calculate denominator only once
+    denom: Persistent[float] = length * (length + 1) / 2
+
+    count: Persistent[int] = 0
+    summ: Persistent[float] = 0.0
+    weighted_summ: Persistent[float] = 0.0
+
+    if (isinstance(source, NA) or source != source):
+        # An NA bar leaves the window unchanged; hold the last full value
+        # (still NA while warming up)
+        return na_float if count < length else weighted_summ / denom
+
+    # NA values are NOT stored in the buffer, only skipped, so ``src[length]``
+    # indexes past NA gaps to the true oldest value still inside the window.
+    # Reading the parameter directly would step back ``length`` *bars* and land
+    # inside an NA gap, subtracting an NA that poisons ``summ`` forever.
+    src: Series[float] = source
+    # Grow the na-compacted buffer so ``src[length]`` stays addressable for lengths
+    # beyond the per-series default max_bars_back (500); otherwise the window-drop
+    # read returns na and poisons ``summ`` permanently.
+    max_bars_back(src, int(length))
+
+    # Warming up phase — only non-NA samples advance the window
+    if count < length:
+        count += 1
+        summ += source
+        weighted_summ += source * count
+        if count < length:
+            return na_float
+
+    # Normal calculation phase
+    else:
+        old_summ = summ
+        # Substract the oldest value and add the newest value
+        summ -= src[length] - source
+        # Substract the oldest weighted value and add the newest weighted value
+        weighted_summ -= old_summ - length * source
+
+    val = weighted_summ / denom
+    return val  # type: ignore
+
+
+def wpr(length: int) -> PyneFloat:
+    """
+    Williams %R indicator.
+
+    :param length: Length of the indicator
+    :return: Williams %R value
+    """
+    assert length > 0, "Invalid length, must be greater than 0!"
+    length = int(length)
+
+    if length == 1:
+        return close
+
+    hmax = highest(high, length)
+    lmin = lowest(low, length)
+
+    return 100 * (close - hmax) / (hmax - lmin)
+
+
+@module_property
+def wvad() -> PyneFloat:
+    """
+    Weighted Volume Accumulation/Distribution.
+
+    :return: Weighted Volume Accumulation/Distribution
+    """
+    return (close - open) / (high - low) * volume