openscript 0.4.0__py3-none-any.whl

openscript/library/strength.py

@@ -0,0 +1,180 @@
+"""The position and strength readings of `stdlib.md` section 20.4.
+
+Each of these asks the same question, where does this bar sit against its recent
+past, and each answers it on a different scale. What they share is an
+arrangement, and the arrangement is the thing two engines part company over:
+
+- **The strength line is ``100 - 100 / (1 + up / down)``**, in that order: the
+  ratio, then one added to it, then 100 divided by that, then subtracted from
+  100. The other reading in circulation, ``100 * up / (up + down)``, is
+  mathematically equal and lands one unit in the last place away on ordinary
+  data. Over the eighty bar fixture the release gate compares bit for bit it
+  differs on about half the values at every length.
+- **The position readings multiply by 100 first**, which is the opposite of the
+  directional index of section 20.3 and is deliberate: each is the association
+  its own reading has always carried, and matching one to the other would move
+  every value of one of them.
+- **The deviation reading divides by the mean absolute deviation**, not by the
+  standard deviation, and the constant is applied to the deviation rather than to
+  the numerator. The 0.015 is calibrated against the mean absolute deviation, and
+  substituting a standard deviation changes every reading while still producing a
+  plausible line.
+
+Naming a value first is not a second arrangement: writing the ratio into a name
+and reading it back is bit identical to writing it out, because every operation
+already rounds its result to binary64 (section 20.1's first rule).
+"""
+
+from typing import Optional
+
+from . import averages, prices
+from .extremes import window_high, window_low
+from .series import Region, back, contributed, mean, region, total, window
+from .values import ABSENT, Value, number, result
+
+
+def line_of(up: Value, down: Value) -> Value:
+    """The strength line both this section's reading and the money flow one take.
+
+    **The result is 100 when the down side is zero**, which also covers a window
+    that never moved and in which both sides are zero. The ratio has no value
+    there, and every reference reading is 100.
+    """
+    if not isinstance(up, float) or not isinstance(down, float):
+        return ABSENT
+    if down == 0:
+        return 100.0
+    return result(100 - 100 / (1 + up / down))
+
+
+def rises_and_falls(values) -> tuple:
+    """This bar's change split into the two sides, each an exact zero where flat.
+
+    The falling side is formed by negating the change and taking the larger of
+    that and zero, so a rising bar contributes an exact zero to it rather than a
+    negative zero that a later division could carry a sign out of.
+    """
+    now = values[len(values) - 1]
+    before = back(values, 1)
+    if not isinstance(now, float) or not isinstance(before, float):
+        return ABSENT, ABSENT
+    delta = now - before
+    up = delta if delta > 0 else 0.0
+    down = -delta if -delta > 0 else 0.0
+    return up, down
+
+
+def strength(state: Region, value: Value, length: Optional[int]) -> Value:
+    """``rsi(src, len)``: the one bar change split, each side smoothed with ``rma``."""
+    values = contributed(state, "src", number(value), 2)
+    up, down = rises_and_falls(values)
+    average_up = averages.smoothed(region(state, "up"), up, length)
+    average_down = averages.smoothed(region(state, "down"), down, length)
+    return line_of(average_up, average_down)
+
+
+def change_ratio(state: Region, value: Value, length: Optional[int]) -> Value:
+    """``cmo(src, len)``: the two sides summed over the window outright, no smoothing."""
+    values = contributed(state, "src", number(value), 2)
+    up, down = rises_and_falls(values)
+    rises = window(contributed(state, "up", up, length), length)
+    falls = window(contributed(state, "down", down, length), length)
+    if rises is None or falls is None:
+        return ABSENT
+    rise = total(rises)
+    fall = total(falls)
+    divisor = rise + fall
+    if divisor == 0:
+        return ABSENT
+    return result((100 * (rise - fall)) / divisor)
+
+
+def position(state: Region, ctx, length: Optional[int], smooth_k, smooth_d) -> list:
+    """``stoch(len, smoothK, smoothD)``: the close inside the window's outright range.
+
+    The range is the bars' own highs and lows and not the close's extremes, and
+    the span is formed once: the result is absent where it is zero, which is a
+    window that did not move at all.
+    """
+    highs = contributed(state, "high", number(ctx.bar("high")), length)
+    lows = contributed(state, "low", number(ctx.bar("low")), length)
+    raw = _placed(
+        number(ctx.bar("close")), window_high(highs, length), window_low(lows, length)
+    )
+    return _smoothed_pair(state, raw, smooth_k, smooth_d)
+
+
+def strength_position(
+    state: Region,
+    value: Value,
+    strength_length: Optional[int],
+    window_length: Optional[int],
+    smooth_k,
+    smooth_d,
+) -> list:
+    """``stochRsi(...)``: the same three lines with the strength reading in place of the close.
+
+    The window high and the window low are taken from the strength reading itself
+    rather than from the bars, which is the whole difference between this and the
+    reading above.
+    """
+    reading = strength(region(state, "rsi"), value, strength_length)
+    values = contributed(state, "src", reading, window_length)
+    raw = _placed(
+        reading if isinstance(reading, float) else None,
+        window_high(values, window_length),
+        window_low(values, window_length),
+    )
+    return _smoothed_pair(state, raw, smooth_k, smooth_d)
+
+
+def range_position(state: Region, ctx, length: Optional[int]) -> Value:
+    """``williamsR(len)``: the same position on the other scale.
+
+    It is formed from the distance below the window high rather than as the
+    stochastic reading less one hundred, which is a different last bit.
+    """
+    highs = contributed(state, "high", number(ctx.bar("high")), length)
+    lows = contributed(state, "low", number(ctx.bar("low")), length)
+    close = number(ctx.bar("close"))
+    top = window_high(highs, length)
+    bottom = window_low(lows, length)
+    if close is None or not isinstance(top, float) or not isinstance(bottom, float):
+        return ABSENT
+    span = top - bottom
+    if span == 0:
+        return ABSENT
+    return result((-100 * (top - close)) / span)
+
+
+def deviation_reading(state: Region, ctx, length: Optional[int]) -> Value:
+    """``cci(len)``: how far the typical price sits from its mean, in deviation units."""
+    price = prices.typical(ctx)
+    held = window(contributed(state, "src", price, length), length)
+    if held is None or length is None or not isinstance(price, float):
+        return ABSENT
+    middle = mean(held, length)
+    spread = 0.0
+    for at in range(length - 1, -1, -1):
+        spread = spread + abs(held[at] - middle)
+    spread = spread / length
+    if spread == 0:
+        return ABSENT
+    return result((price - middle) / (0.015 * spread))
+
+
+def _placed(value: Optional[float], top: Value, bottom: Value) -> Value:
+    """The position of a value inside a span, scaled by 100 before the division."""
+    if value is None or not isinstance(top, float) or not isinstance(bottom, float):
+        return ABSENT
+    span = top - bottom
+    if span == 0:
+        return ABSENT
+    return result((100 * (value - bottom)) / span)
+
+
+def _smoothed_pair(state: Region, raw: Value, smooth_k, smooth_d) -> list:
+    """The two smoothed lines both position readings report, in that order."""
+    fast = averages.simple(region(state, "k"), raw, smooth_k)
+    slow = averages.simple(region(state, "d"), fast, smooth_d)
+    return [fast, slow]

openscript/library/strings.py

@@ -0,0 +1,228 @@
+"""Strings, `stdlib.md` section 10.
+
+None of these has a warmup: a string operation on a present string produces a
+value on bar 0. Every one is absent when an argument it needs is absent, and none
+of them raises: the string and array ceilings of `compiled-program.md` section
+2.4 are the interpreter's to enforce, and the two measuring functions here exist
+so that it can enforce them before a string is built rather than after.
+
+**Every index and every length counts code points**, through ``code_points``. On
+this host that is what the string type already is, which makes the rule free and
+does not make it optional.
+
+**Case conversion is invariant rather than locale aware.** A script whose output
+changed because the machine running it was configured for another locale would
+break the determinism rule of `language.md` section 7.6, and the cases where a
+locale aware conversion differs are not cases a trading script needs. What the
+page does not say is which case conversion, and that is a gap worth naming:
+"upper case, invariant" is the host's default mapping here and the host's default
+mapping there, and the two agree on every letter a symbol or a label is likely to
+hold and are not guaranteed to agree on every code point. An engine is held to
+the conformance suite's strings, not to this sentence.
+"""
+
+from .code_points import trimmed
+from .number_text import spell
+from .values import ABSENT, Value, whole
+
+
+def _string(value: Value) -> str | None:
+    """A string argument, or absence for anything that is not one."""
+    return value if isinstance(value, str) else None
+
+
+def length(s: Value) -> Value:
+    """``str.length(s)``: count of Unicode code points."""
+    text = _string(s)
+    return ABSENT if text is None else float(len(text))
+
+
+def upper(s: Value) -> Value:
+    """``str.upper(s)``: upper case, invariant, not locale dependent."""
+    text = _string(s)
+    return ABSENT if text is None else text.upper()
+
+
+def lower(s: Value) -> Value:
+    """``str.lower(s)``: lower case, on the same terms."""
+    text = _string(s)
+    return ABSENT if text is None else text.lower()
+
+
+def trim(s: Value) -> Value:
+    """``str.trim(s)``: the whitespace of section 10's table, off both ends."""
+    text = _string(s)
+    return ABSENT if text is None else trimmed(text)
+
+
+def contains(s: Value, part: Value) -> Value:
+    """``str.contains(s, part)``: whether one string appears in another."""
+    text = _string(s)
+    piece = _string(part)
+    if text is None or piece is None:
+        return ABSENT
+    return piece in text
+
+
+def starts_with(s: Value, part: Value) -> Value:
+    """``str.startsWith(s, part)``: prefix test."""
+    text = _string(s)
+    piece = _string(part)
+    if text is None or piece is None:
+        return ABSENT
+    return text.startswith(piece)
+
+
+def ends_with(s: Value, part: Value) -> Value:
+    """``str.endsWith(s, part)``: suffix test."""
+    text = _string(s)
+    piece = _string(part)
+    if text is None or piece is None:
+        return ABSENT
+    return text.endswith(piece)
+
+
+def index_of(s: Value, part: Value) -> Value:
+    """``str.indexOf(s, part)``: first position of ``part``, or -1.
+
+    The position is in code points, which is what this host's own search already
+    reports; an engine whose strings are sixteen bit units converts, or it hands
+    a script an index that its own substring call then reads as a different one.
+    """
+    text = _string(s)
+    piece = _string(part)
+    if text is None or piece is None:
+        return ABSENT
+    return float(text.find(piece))
+
+
+def substring(s: Value, start: Value, stop: Value) -> Value:
+    """``str.substring(s, from, to = none)``: from inclusive, to exclusive.
+
+    An absent ``to`` runs to the end, which is the default the page states, and
+    is why absence is not propagated from that argument alone.
+    """
+    text = _string(s)
+    first = whole(start)
+    if text is None or first is None:
+        return ABSENT
+    if stop is None:
+        return text[first:]
+    last = whole(stop)
+    if last is None:
+        return ABSENT
+    return text[first:last]
+
+
+def replace(s: Value, find: Value, into: Value) -> Value:
+    """``str.replace(s, find, with)``: the first occurrence only."""
+    text = _string(s)
+    needle = _string(find)
+    other = _string(into)
+    if text is None or needle is None or other is None:
+        return ABSENT
+    return text.replace(needle, other, 1)
+
+
+def replace_all(s: Value, find: Value, into: Value) -> Value:
+    """``str.replaceAll(s, find, with)``: every occurrence."""
+    text = _string(s)
+    needle = _string(find)
+    other = _string(into)
+    if text is None or needle is None or other is None:
+        return ABSENT
+    return text.replace(needle, other)
+
+
+def split(s: Value, separator: Value) -> list[str] | None:
+    """``str.split(s, separator)``: the parts, for the interpreter to make an array.
+
+    The array is the interpreter's to allocate, because the heap is, so this
+    returns the parts and absence stands for a call that produces nothing.
+
+    **An empty separator splits into code points**, which is
+    `compiled-program.md` section 3.1's rule and not every host's: a host whose
+    strings are sixteen bit units splits a symbol outside the basic plane into
+    two halves of a surrogate pair, neither of which is a string the language has
+    a value for.
+    """
+    text = _string(s)
+    mark = _string(separator)
+    if text is None or mark is None:
+        return None
+    if mark == "":
+        return list(text)
+    return text.split(mark)
+
+
+def join(parts: list[Value], separator: Value) -> Value:
+    """``str.join(parts, separator)``: an array back into one string.
+
+    An element that is not a string is spelled as ``text`` spells it, which is
+    what makes joining an array of numbers produce the same characters as writing
+    each of them.
+    """
+    mark = _string(separator)
+    if parts is None or mark is None:
+        return ABSENT
+    return mark.join(spell(item) for item in parts)
+
+
+def _pad(text: str, width: int, fill: str, left: bool) -> str:
+    if len(text) >= width:
+        return text
+    needed = width - len(text)
+    padding = "".join(fill[at % len(fill)] for at in range(needed))
+    return padding + text if left else text + padding
+
+
+def pad_left(s: Value, width: Value, fill: Value) -> Value:
+    """``str.padLeft(s, width, fill = " ")``: pad to a width, for a column.
+
+    The padding is the fill repeated and cut to length, code point by code point,
+    rather than the fill repeated a whole number of times: a two character fill
+    padding an odd gap has to stop halfway, and where it stops is what a table
+    column lines up on.
+    """
+    return _padded(s, width, fill, True)
+
+
+def pad_right(s: Value, width: Value, fill: Value) -> Value:
+    """``str.padRight(s, width, fill = " ")``: the same from the other side."""
+    return _padded(s, width, fill, False)
+
+
+def _padded(s: Value, width: Value, fill: Value, left: bool) -> Value:
+    text = _string(s)
+    if text is None:
+        return ABSENT
+    size = whole(width)
+    filler = _string(fill)
+    if filler is None:
+        filler = " "
+    if size is None or filler == "":
+        return text
+    return _pad(text, size, filler, left)
+
+
+def repeat(s: Value, count: Value) -> Value:
+    """``str.repeat(s, n)``: ``n`` copies, for a bar drawn out of characters."""
+    text = _string(s)
+    times = whole(count)
+    if text is None or times is None:
+        return ABSENT
+    return text * times
+
+
+def repeat_length(s: Value, count: Value) -> int | None:
+    """How long ``str.repeat`` will be, before a character of it is built.
+
+    A length times a count is where the string ceiling is actually reached, and
+    building the string to find that out is how an engine runs out of memory
+    instead of reporting that it would have.
+    """
+    text = _string(s)
+    times = whole(count)
+    if text is None or times is None:
+        return None
+    return len(text) * times

openscript/library/trend.py

@@ -0,0 +1,260 @@
+"""The trend studies of `stdlib.md` section 20.3 that carry a decision from bar to bar.
+
+These five are the ones where a seeding rule is not a detail. A band that starts
+on the wrong side, a stop clamped into the previous two bars' range, or a
+directional reading smoothed against the wrong range is a **different study**
+rather than a different last bit: it flips on different bars and stays apart
+until a later flip happens to put the two back together. So each entry below
+says what it is not, and the reason is in section 20.3 rather than here.
+
+Both bands and both stops keep their state as plain numbers and a side, because
+section 2.11 requires a region an engine can copy without knowing whose it is.
+"""
+
+from typing import Optional
+
+from . import averages, ranges
+from .extremes import high_at, low_at
+from .ranges import gap_range
+from .series import Region, contributed, raw_window, region, window
+from .values import ABSENT, Value, number, result
+
+#: The two directions, as section 4 reports them: the sign of the side the band
+#: is protecting against, so that ``direction != direction[1]`` reads as the flip.
+LONG = -1.0
+SHORT = 1.0
+
+
+def trailing_band(state: Region, ctx, factor: Value, width_length: Optional[int]) -> list:
+    """``supertrend(factor, atrLen)``: a trailing band from the average true range.
+
+    On the first bar the width is available on, both bands are the raw bands,
+    **the line starts on the upper band**, and the bar reports absence: the carry
+    forward and the flip test both read the previous bar's close and the previous
+    bar's bands, and on that bar there is neither. The band it leaves the state
+    on is the one the bar after it inherits.
+
+    Starting on the lower band is a different study. Measured over four hundred
+    bars at three parameter sets, a line seeded there differed on between fifteen
+    and forty of the bars it reported, by as much as sixteen price units, with the
+    direction inverted on exactly those bars.
+    """
+    width = ranges.average_range(region(state, "width"), ctx, width_length)
+    high = number(ctx.bar("high"))
+    low = number(ctx.bar("low"))
+    close = number(ctx.bar("close"))
+    before = number(ctx.bar("previousClose"))
+    multiple = number(factor)
+    held = region(state, "band")
+    if not isinstance(width, float) or high is None or low is None or close is None:
+        return [ABSENT, ABSENT]
+    if multiple is None:
+        return [ABSENT, ABSENT]
+    midpoint = (high + low) / 2
+    raw_upper = midpoint + multiple * width
+    raw_lower = midpoint - multiple * width
+    upper = held.get("upper")
+    lower = held.get("lower")
+    if upper is None or lower is None or before is None:
+        upper, lower = raw_upper, raw_lower
+        held["upper"] = upper
+        held["lower"] = lower
+        held["upside"] = not close > upper
+        return [ABSENT, ABSENT]
+    if raw_upper < upper or before > upper:
+        upper = raw_upper
+    if raw_lower > lower or before < lower:
+        lower = raw_lower
+    upside = held.get("upside", True)
+    upside = close <= upper if upside else not close >= lower
+    held["upper"] = upper
+    held["lower"] = lower
+    held["upside"] = upside
+    return [result(upper if upside else lower), SHORT if upside else LONG]
+
+
+def accelerating_stop(
+    state: Region, ctx, start: Value, step: Value, most: Value
+) -> list:
+    """``psar(start, step, max)``: a stop that accelerates toward price.
+
+    The stop moves first, then the flip test, then the extreme test, in that
+    order. **The second test is reached on a flip bar as well**, where it cannot
+    fire, because the extreme has just been set to this bar's own low or high and
+    both comparisons are strict, so an engine that writes them as one chain and
+    an engine that writes them as two agree on every bar.
+
+    **The stop is reported as the recurrence produced it, and there is no clamp.**
+    Holding it out of the previous two bars' range swallows flips this recurrence
+    fires, because the next bar's flip test reads the stop this bar left behind.
+    The two are different functions rather than two arrangements of one.
+    """
+    high = number(ctx.bar("high"))
+    low = number(ctx.bar("low"))
+    close = number(ctx.bar("close"))
+    first = number(start)
+    rise = number(step)
+    ceiling = number(most)
+    held = region(state, "stop")
+    highs = contributed(state, "high", high, 2)
+    lows = contributed(state, "low", low, 2)
+    closes = contributed(state, "close", close, 2)
+    if high is None or low is None or close is None:
+        return [ABSENT, ABSENT]
+    if first is None or rise is None or ceiling is None:
+        return [ABSENT, ABSENT]
+    stop = held.get("stop")
+    if stop is None:
+        return _seed_stop(held, highs, lows, closes, first)
+    long = held.get("long", True)
+    speed = held.get("speed", first)
+    extreme = held.get("extreme", high)
+    stop = stop + speed * (extreme - stop)
+    if long and stop > low:
+        long = False
+        stop = extreme
+        extreme = low
+        speed = first
+    elif not long and stop < high:
+        long = True
+        stop = extreme
+        extreme = high
+        speed = first
+    if long and high > extreme:
+        extreme = high
+        speed = min(speed + rise, ceiling)
+    elif not long and low < extreme:
+        extreme = low
+        speed = min(speed + rise, ceiling)
+    held["stop"] = stop
+    held["long"] = long
+    held["speed"] = speed
+    held["extreme"] = extreme
+    return [result(stop), LONG if long else SHORT]
+
+
+def _seed_stop(held: Region, highs, lows, closes, first: float) -> list:
+    """The seed of section 20.3: the first pair of complete bars, and that bar reports it."""
+    if len(closes) < 2 or not isinstance(closes[len(closes) - 2], float):
+        return [ABSENT, ABSENT]
+    before = closes[len(closes) - 2]
+    now = closes[len(closes) - 1]
+    high = highs[len(highs) - 1]
+    low = lows[len(lows) - 1]
+    long = now > before
+    stop = lows[len(lows) - 2] if long else highs[len(highs) - 2]
+    if not isinstance(stop, float):
+        return [ABSENT, ABSENT]
+    held["stop"] = stop
+    held["long"] = long
+    held["speed"] = first
+    held["extreme"] = high if long else low
+    return [result(stop), LONG if long else SHORT]
+
+
+def directional(state: Region, ctx, di_length: Optional[int], adx_length: Optional[int]) -> list:
+    """``adx(diLen, adxLen)``: directional movement against the gap aware true range.
+
+    All three smoothed quantities cover the same bars, which is what the gap
+    aware form is for: the plain reading's exception on the oldest bar would put
+    the range one bar ahead of the two movements and the strength reading would
+    be built from three windows that do not line up.
+
+    **The division comes before the multiplication by 100 on all three lines.**
+    The other association is the one the readings of section 20.4 use and it is a
+    different number here.
+    """
+    high = number(ctx.bar("high"))
+    low = number(ctx.bar("low"))
+    highs = contributed(state, "high", high, 2)
+    lows = contributed(state, "low", low, 2)
+    before_high = highs[len(highs) - 2] if len(highs) > 1 else ABSENT
+    before_low = lows[len(lows) - 2] if len(lows) > 1 else ABSENT
+    up_move = ABSENT
+    down_move = ABSENT
+    if high is not None and low is not None:
+        if isinstance(before_high, float) and isinstance(before_low, float):
+            up = high - before_high
+            down = before_low - low
+            up_move = up if up > down and up > 0 else 0.0
+            down_move = down if down > up and down > 0 else 0.0
+    smoothed_up = averages.smoothed(region(state, "up"), up_move, di_length)
+    smoothed_down = averages.smoothed(region(state, "down"), down_move, di_length)
+    smoothed_range = averages.smoothed(region(state, "range"), gap_range(ctx), di_length)
+    plus = _reading(smoothed_up, smoothed_range)
+    minus = _reading(smoothed_down, smoothed_range)
+    spread = ABSENT
+    if isinstance(plus, float) and isinstance(minus, float):
+        divisor = plus + minus
+        spread = 0.0 if divisor == 0 else (abs(plus - minus) / divisor) * 100
+    strength = averages.smoothed(region(state, "adx"), spread, adx_length)
+    return [strength, plus, minus]
+
+
+def _reading(side: Value, width: Value) -> Value:
+    """One directional reading: the division, then the multiplication by 100."""
+    if not isinstance(side, float) or not isinstance(width, float) or width == 0:
+        return ABSENT
+    return result((side / width) * 100)
+
+
+def ages(state: Region, ctx, length: Optional[int]) -> list:
+    """``aroon(len)``: how recently the window's high and low were set, as a percentage.
+
+    The window is ``len + 1`` bars wide, so an extreme set ``len`` bars ago is
+    still inside it and a reading of 0 is reachable. The two ages are counted
+    under the tie rule of section 20.10: the most recent bar that set the extreme.
+    """
+    span = None if length is None else length + 1
+    highs = window(contributed(state, "high", number(ctx.bar("high")), span), span)
+    lows = window(contributed(state, "low", number(ctx.bar("low")), span), span)
+    if highs is None or lows is None or length is None:
+        return [ABSENT, ABSENT]
+    up = (100 * (length - high_at(highs))) / length
+    down = (100 * (length - low_at(lows))) / length
+    return [result(up), result(down)]
+
+
+def cloud(
+    state: Region, ctx, conversion_length: Optional[int], base_length: Optional[int],
+    span_length: Optional[int],
+) -> list:
+    """``ichimoku(convLen, baseLen, spanLen)``: the five line frame, undisplaced.
+
+    Each of the first four lines is the midpoint of a window's outright extremes.
+    The third is the mean of the two midpoints already computed at the shorter two
+    lengths, and not a midpoint recomputed over a window of its own. The fifth is
+    this bar's close, reported at the bar it belongs to: a study draws the spans
+    and the lagging line forward or back with the plot's own offset, because a
+    shifted series cannot be compared with anything else in the script without
+    shifting it back.
+    """
+    deepest = _deepest(conversion_length, base_length, span_length)
+    highs = contributed(state, "high", number(ctx.bar("high")), deepest)
+    lows = contributed(state, "low", number(ctx.bar("low")), deepest)
+    conversion = _midpoint(highs, lows, conversion_length)
+    base = _midpoint(highs, lows, base_length)
+    leading = ABSENT
+    if isinstance(conversion, float) and isinstance(base, float):
+        leading = result((conversion + base) / 2)
+    second = _midpoint(highs, lows, span_length)
+    lagging = ABSENT
+    if raw_window(highs, base_length) is not None:
+        lagging = number(ctx.bar("close"))
+        lagging = ABSENT if lagging is None else result(lagging)
+    return [conversion, base, leading, second, lagging]
+
+
+def _deepest(*lengths) -> Optional[int]:
+    """The widest window any of the lines asks for, which is what the buffer keeps."""
+    known = [one for one in lengths if one is not None]
+    return max(known) if known else None
+
+
+def _midpoint(highs, lows, length: Optional[int]) -> Value:
+    """The midpoint of a window's outright extremes, which four of the five lines are."""
+    top = window(highs, length)
+    bottom = window(lows, length)
+    if top is None or bottom is None:
+        return ABSENT
+    return result((top[high_at(top)] + bottom[low_at(bottom)]) / 2)