openscript 0.6.0__tar.gz → 0.7.0__tar.gz

{openscript-0.6.0 → openscript-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscript
-Version: 0.6.0
+Version: 0.7.0
 Summary: An open trading language: the engine that runs a compiled program.
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/marketcalls/openscript#readme
@@ -39,6 +39,16 @@ where any disagreement is a release blocker.
   stop a run being reproducible. Measured on every build against the module
   names the running interpreter says are its own.
 
+## Numerical results in 0.7.0
+
+The two engines use the same specified rounding, seeds and missing-value rules.
+Portable elementary kernels remove host-dependent final-bit differences; the
+release audit requires exact agreement for every numerical signature it covers,
+including forming-bar replacement and checkpoint replay. Install the matching
+0.7.0 compiler package when comparing browser and server results. Source calls
+and the compiled format are unchanged, but corrected results can differ from
+previous releases.
+
 ## Installing
 
 ```

{openscript-0.6.0 → openscript-0.7.0}/README.md

@@ -25,6 +25,16 @@ where any disagreement is a release blocker.
   stop a run being reproducible. Measured on every build against the module
   names the running interpreter says are its own.
 
+## Numerical results in 0.7.0
+
+The two engines use the same specified rounding, seeds and missing-value rules.
+Portable elementary kernels remove host-dependent final-bit differences; the
+release audit requires exact agreement for every numerical signature it covers,
+including forming-bar replacement and checkpoint replay. Install the matching
+0.7.0 compiler package when comparing browser and server results. Source calls
+and the compiled format are unchanged, but corrected results can differ from
+previous releases.
+
 ## Installing
 
 ```

{openscript-0.6.0 → openscript-0.7.0}/openscript/library/__init__.py

@@ -13,7 +13,7 @@ What is here, by the page it is written from:
 - ``values``        absence, and the two rules every number returned has passed
 - ``arithmetic``    section 8.1, the bare calls that compute one value
 - ``rounding``      section 8.1 and 20.7, one rule for halves and one scale table
-- ``elementary``    section 8.2, the square root and the gap 1 family
+- ``elementary``    section 8.2 and the portable arithmetic of section 20.10
 - ``bars``          section 20.5's one reading that remembers nothing
 - ``code_points``   section 10's whitespace set and the one string order
 - ``number_text``   `language.md` 5.5, how a number becomes text and back
@@ -50,12 +50,10 @@ mechanical copy without the engine knowing which function it belongs to. A
 stateless call needs none, which is what lets an engine call one of those from
 anywhere without a checkpoint or a rollback.
 
-**One family is not held to the vectors.** ``exp``, ``log``, ``log10``,
-``math.log2``, ``pow``, ``math.hypot`` and the trigonometric namespace reach gap 1
-of `stdlib.md` section 20.11, and so do ``alma``, ``hv`` and ``chop``, which are
-built on the first three: no portable reference algorithm is written down
-anywhere, so they call the host's maths module and carry no cross-engine
-guarantee. ``elementary`` says it again where an implementer will be standing.
+Power and the trigonometric namespace still reach gap 1 of `stdlib.md` section
+20.11. Hypotenuse follows section 20.10.1, while exponential and logarithmic
+functions follow section 20.10.2. Those portable kernels and every stateful
+reading, including ``alma``, ``hv`` and ``chop``, are held to exact vector bits.
 """
 
 from .stateful import ENTRIES as STATEFUL_ENTRIES

{openscript-0.6.0 → openscript-0.7.0}/openscript/library/arithmetic.py

@@ -12,7 +12,7 @@ exception and its order is written out in section 8.1 and confirmed in 20.7: the
 division, then the floor, then the multiplication, then the subtraction.
 """
 
-from .values import ABSENT, Value, floor_of, number, result
+from .values import ABSENT, Value, floor_of, is_number, number, result
 
 
 def abs_of(x: Value) -> Value:
@@ -110,10 +110,11 @@ def is_none(x: Value) -> bool:
 def or_else(x: Value, fallback: Value) -> Value:
     """``orElse(x, fallback)``: ``x`` when present, ``fallback`` when absent.
 
-    The fallback is returned as it stands, absence included, so
-    ``orElse(x, none)`` is ``x``.
+    Absence and every nonnumeric tag keep their identity; numeric zero follows
+    the same positive-zero rule as other library results.
     """
-    return fallback if x is None else x
+    value = fallback if x is None else x
+    return 0.0 if is_number(value) and value == 0 else value
 
 
 def to_bool(x: Value) -> bool:

{openscript-0.6.0 → openscript-0.7.0}/openscript/library/averages.py

@@ -6,10 +6,9 @@ rather than one is the step and the weighting, and what makes each of them one
 function rather than a family is the arrangement, which is why every entry here
 names the arrangement it is not.
 
-A value arrives already read off this bar's arguments, and every one of these
-pushes it into a buffer of its own before it looks at the window, because a call
-that skipped a bar's contribution would have a window a bar out of step with the
-bars it is supposed to cover.
+A value arrives already read off this bar's arguments. Every invocation counts
+as a contribution, including one with an absent length. Finite windows retain
+their contributions; a seeded recurrence releases its history after seeding.
 """
 
 from .series import Region, contributed, mean, seeded, total, window
@@ -34,16 +33,13 @@ def exponential(state: Region, value: Value, length: int | None) -> Value:
     rather than two, and over the fixture the release gate compares bit for bit
     it differs on most of the values at every length.
     """
-    values = contributed(state, "src", number(value), length)
-    if length is None:
-        return ABSENT
-    weight = 2 / (length + 1)
+    weight = 0.0 if length is None else 2 / (length + 1)
     rest = 1 - weight
 
     def step(running: float, value: float) -> float:
         return value * weight + running * rest
 
-    return seeded(state, "run", values, length, step)
+    return seeded(state, "run", number(value), length, step)
 
 
 def smoothed(state: Region, value: Value, length: int | None) -> Value:
@@ -56,15 +52,12 @@ def smoothed(state: Region, value: Value, length: int | None) -> Value:
     most often asked to reproduce. Neither is
     ``running + (value - running) / len``, which is a third arrangement again.
     """
-    values = contributed(state, "src", number(value), length)
-    if length is None:
-        return ABSENT
-    span = float(length)
+    span = 1.0 if length is None else float(length)
 
     def step(running: float, value: float) -> float:
         return (running * (span - 1) + value) / span
 
-    return seeded(state, "run", values, length, step)
+    return seeded(state, "run", number(value), length, step)
 
 
 def linear(state: Region, value: Value, length: int | None) -> Value:

{openscript-0.6.0 → openscript-0.7.0}/openscript/library/bookkeeping.py

@@ -21,6 +21,7 @@ make the same way twice for two engines to agree:
 
 from typing import Optional
 
+from .history import ContributionHistory
 from .series import Region, back, contributed, raw_window, region
 from .values import ABSENT, Value, number, result
 
@@ -150,17 +151,12 @@ def value_when(
     """
     wanted = 0 if occurrence is None else occurrence
     held = region(state, "seen")
-    values = held.get("values")
-    if values is None:
-        values = []
-        held["values"] = values
+    history = held.get("history")
+    if not isinstance(history, ContributionHistory):
+        history = ContributionHistory()
     if condition is True:
-        values.append(value)
-    depth = max(wanted + 1, held.get("depth", 1))
-    held["depth"] = depth
-    extra = len(values) - depth
-    if extra > 0:
-        del values[:extra]
-    if wanted < 0 or len(values) <= wanted:
+        history = history.append(value, None)
+        held["history"] = history
+    if wanted < 0 or history.count <= wanted:
         return ABSENT
-    return values[len(values) - 1 - wanted]
+    return history.view(wanted + 1)[0]

{openscript-0.6.0 → openscript-0.7.0}/openscript/library/composites.py

@@ -6,8 +6,8 @@ inner one produced, not on the first bars of the source. That composition is the
 whole reason `stdlib.md` section 1 states warmups in bars of the call's own
 source rather than in bars of the chart.
 
-The other two compute over the window directly: the Gaussian kernel, whose one
-dependence on the exponential puts it in gap 1 of section 20.11, and the least
+The other two compute over the window directly: the portable Gaussian kernel
+of section 20.10.2, and the least
 squares fit, whose constants are functions of the length alone.
 
 ``named`` is here rather than beside the six means because it has to be able to
@@ -17,6 +17,7 @@ select any of them, this file's included.
 import math
 
 from . import averages, elementary
+from .gaussian import gaussian_weights
 from .rounding import round_half_away
 from .series import Region, contributed, region, window
 from .values import ABSENT, Value, number, result, whole
@@ -140,10 +141,8 @@ def gaussian(
     order. The denominator of the exponent is **one product, divided once**: the
     chain of divisions in circulation differs on about one exponent in four.
 
-    **This is the one average whose value depends on ``exp``**, so it reaches gap
-    1 of section 20.11 and carries no cross-engine guarantee. The kernel depends
-    only on the position, so an engine may build it once per length, provided the
-    values it builds are the ones these lines produce.
+    A bounded pure cache holds immutable weights for exact parameter values.
+    It holds no source observations and does not enter checkpoint state.
     """
     values = contributed(state, "src", number(value), length)
     held = window(values, length)
@@ -151,19 +150,12 @@ def gaussian(
     width = number(sigma)
     if held is None or length is None or peak_at is None or width is None:
         return ABSENT
-    if width == 0:
+    if width <= 0:
         return ABSENT
-    peak = peak_at * (length - 1)
-    spread = length / width
-    weights = []
-    norm = 0.0
-    for position in range(length):
-        gap = position - peak
-        weight = elementary.exp(-(gap * gap) / (2 * spread * spread))
-        if not isinstance(weight, float):
-            return ABSENT
-        weights.append(weight)
-        norm = norm + weight
+    kernel = gaussian_weights(length, peak_at, width)
+    if kernel is None:
+        return ABSENT
+    weights, norm = kernel
     running = 0.0
     for position in range(length):
         running = running + held[length - 1 - position] * weights[position]

{openscript-0.6.0 → openscript-0.7.0}/openscript/library/deviation.py

@@ -128,18 +128,19 @@ def historical(
     of log returns and says nothing about a percentage, so a study that wants a
     percentage axis multiplies at the plot, where a reader can see it happen.
 
-    **This reading depends on ``log``**, so it reaches gap 1 of section 20.11 and
-    carries no cross-engine guarantee.
+    The logarithm follows the portable interval recipe of section 20.10.2.
     """
     values = contributed(state, "src", number(value), 2)
     now = values[len(values) - 1]
     before = values[len(values) - 2] if len(values) > 1 else ABSENT
     ratio = ABSENT
-    if isinstance(now, float) and isinstance(before, float) and before != 0:
+    if isinstance(now, float) and isinstance(before, float) and now > 0 and before > 0:
         ratio = now / before
     step = elementary.log(ratio)
     spread = deviation(region(state, "spread"), step, length, False)
     count = number(periods)
+    if count is None or count <= 0:
+        return ABSENT
     scale = elementary.sqrt(count)
     if not isinstance(spread, float) or not isinstance(scale, float):
         return ABSENT

openscript-0.7.0/openscript/library/elementary.py

@@ -0,0 +1,146 @@
+"""Elementary numeric functions with reproducible rounding.
+
+Hypotenuse and exp/log use the exact integer recipes in sections 20.10.1 and
+20.10.2; power and trigonometry use sections 20.10.3 and 20.10.4.
+Square root uses its correctly rounded host operation.
+"""
+
+import math
+
+from .hypotenuse import hypotenuse
+from .transcendental import transcendental
+from .power import power as real_power
+from .trigonometric import trigonometric
+from .values import ABSENT, Value, number, result
+
+# The circle constant and the base of the natural logarithm, as `stdlib.md`
+# section 8.2 names them. Both are the nearest binary64 to the constant and are
+# the same bits on every platform.
+PI: float = math.pi
+E: float = math.e
+
+
+def sqrt(x: Value) -> Value:
+    """``sqrt(x)``: square root, absent below zero."""
+    value = number(x)
+    if value is None or value < 0:
+        return ABSENT
+    return result(math.sqrt(value))
+
+
+def exp(x: Value) -> Value:
+    """``exp(x)``: e to the power x, using section 20.10.2."""
+    value = number(x)
+    return ABSENT if value is None else transcendental('exp', value)
+
+
+def log(x: Value) -> Value:
+    """``log(x)``: portable natural logarithm, absent at or below zero."""
+    value = number(x)
+    if value is None or value <= 0:
+        return ABSENT
+    return transcendental('log', value)
+
+
+def log10(x: Value) -> Value:
+    """``log10(x)``: portable base ten logarithm, same absence rule."""
+    value = number(x)
+    if value is None or value <= 0:
+        return ABSENT
+    return transcendental('log10', value)
+
+
+def log2(x: Value) -> Value:
+    """``math.log2(x)``: portable base two logarithm, same absence rule."""
+    value = number(x)
+    if value is None or value <= 0:
+        return ABSENT
+    return transcendental('log2', value)
+
+
+def power(x: Value, y: Value) -> Value:
+    """``pow(x, y)``: portable real power, using section 20.10.3."""
+    base = number(x)
+    exponent = number(y)
+    if base is None or exponent is None:
+        return ABSENT
+    return real_power(base, exponent)
+
+
+def hypot(x: Value, y: Value) -> Value:
+    """``math.hypot(x, y)``: the correctly rounded exact diagonal, section 20.10.1."""
+    left = number(x)
+    right = number(y)
+    if left is None or right is None:
+        return ABSENT
+    return hypotenuse(left, right)
+
+
+def to_degrees(x: Value) -> Value:
+    """``math.toDegrees(x)``: ``(x * 180) / pi``, multiply first.
+
+    Not a gap: it is two operations over binary64 and `stdlib.md` section 20.7
+    fixes their order. Folding the constant into one factor is a different number
+    at about a quarter of the arguments, so the association is written out rather
+    than handed to a conversion the host provides.
+    """
+    value = number(x)
+    return ABSENT if value is None else result((value * 180) / math.pi)
+
+
+def to_radians(x: Value) -> Value:
+    """``math.toRadians(x)``: ``(x * pi) / 180``, multiply first. Not a gap."""
+    value = number(x)
+    return ABSENT if value is None else result((value * math.pi) / 180)
+
+
+def sin(x: Value) -> Value:
+    """``math.sin(x)``: sine of an angle in radians, using section 20.10.4."""
+    value = number(x)
+    return ABSENT if value is None else trigonometric('sin', value)
+
+
+def cos(x: Value) -> Value:
+    """``math.cos(x)``: cosine, using section 20.10.4."""
+    value = number(x)
+    return ABSENT if value is None else trigonometric('cos', value)
+
+
+def tan(x: Value) -> Value:
+    """``math.tan(x)``: tangent, using section 20.10.4."""
+    value = number(x)
+    return ABSENT if value is None else trigonometric('tan', value)
+
+
+def asin(x: Value) -> Value:
+    """``math.asin(x)``: inverse sine, absent outside -1 to 1."""
+    value = number(x)
+    if value is None or value < -1 or value > 1:
+        return ABSENT
+    return trigonometric('asin', value)
+
+
+def acos(x: Value) -> Value:
+    """``math.acos(x)``: inverse cosine, same range rule."""
+    value = number(x)
+    if value is None or value < -1 or value > 1:
+        return ABSENT
+    return trigonometric('acos', value)
+
+
+def atan(x: Value) -> Value:
+    """``math.atan(x)``: inverse tangent, using section 20.10.4."""
+    value = number(x)
+    return ABSENT if value is None else trigonometric('atan', value)
+
+
+def atan2(y: Value, x: Value) -> Value:
+    """``math.atan2(y, x)``: angle of a vector, in all four quadrants.
+
+    The vertical component comes first, as section 20.10.4 specifies.
+    """
+    vertical = number(y)
+    horizontal = number(x)
+    if vertical is None or horizontal is None:
+        return ABSENT
+    return trigonometric('atan2', vertical, horizontal)

{openscript-0.6.0 → openscript-0.7.0}/openscript/library/flows.py

@@ -44,11 +44,12 @@ def _anchored(state: Region, ctx, value: Value, anchor: Value) -> Value:
     held = region(state, "vwap")
     price = number(value)
     traded = number(ctx.bar("volume"))
-    if anchor is not True and anchor is not False:
-        return ABSENT
-    if anchor:
+    if anchor is True:
         held["flow"] = 0.0
         held["traded"] = 0.0
+        held["anchored"] = True
+    if held.get("anchored") is not True:
+        return ABSENT
     if price is None or traded is None:
         return ABSENT
     flow = held.get("flow", 0.0) + price * traded
@@ -113,10 +114,11 @@ def flow_fraction(state: Region, ctx, length: Optional[int]) -> Value:
     traded = window(volumes, length)
     if held is None or traded is None:
         return ABSENT
-    divisor = total(traded)
-    if divisor == 0:
+    flow = result(total(held))
+    divisor = result(total(traded))
+    if flow is None or divisor is None or divisor == 0:
         return ABSENT
-    return result(total(held) / divisor)
+    return result(flow / divisor)
 
 
 def accumulation_gap(
@@ -164,14 +166,14 @@ def money_flow(state: Region, ctx, length: Optional[int]) -> Value:
     rise = ABSENT
     fall = ABSENT
     if isinstance(price, float) and traded is not None and isinstance(before, float):
-        flow = price * traded
+        flow = result(price * traded)
         rise = flow if price > before else 0.0
         fall = flow if price < before else 0.0
     rises = window(contributed(state, "rise", rise, length), length)
     falls = window(contributed(state, "fall", fall, length), length)
     if rises is None or falls is None:
         return ABSENT
-    return strength.line_of(total(rises), total(falls))
+    return strength.line_of(result(total(rises)), result(total(falls)))
 
 
 def movement(state: Region, ctx, length: Optional[int]) -> Value:

openscript-0.7.0/openscript/library/gaussian.py

@@ -0,0 +1,51 @@
+"""Bounded immutable Gaussian coefficients, independent of checkpoint state."""
+import math
+import struct
+
+from .elementary import exp
+
+
+class GaussianCache:
+    """FIFO with eight parameter tuples and at most 4096 coefficients."""
+    def __init__(self):
+        self.entries = {}
+        self.coefficients = 0
+
+    def get(self, length, offset, sigma):
+        if not math.isfinite(offset) or not math.isfinite(sigma) or sigma <= 0:
+            return None
+        key = (length, struct.pack('>d', offset), struct.pack('>d', sigma))
+        if key in self.entries:
+            return self.entries[key]
+        peak, spread = offset * (length - 1), length / sigma
+        denominator = (2 * spread) * spread
+        if denominator == 0:
+            return None
+        weights = []
+        norm = 0.0
+        for position in range(length):
+            gap = position - peak
+            exponent = -(gap * gap) / denominator
+            weight = 0.0 if exponent == -math.inf else exp(exponent)
+            if weight is None:
+                return None
+            weights.append(weight)
+            norm += weight
+        if norm == 0:
+            return None
+        computed = (tuple(weights), norm)
+        if length <= 4096:
+            while len(self.entries) >= 8 or self.coefficients + length > 4096:
+                oldest = next(iter(self.entries))
+                self.coefficients -= len(self.entries[oldest][0])
+                del self.entries[oldest]
+            self.entries[key] = computed
+            self.coefficients += length
+        return computed
+
+
+_CACHE = GaussianCache()
+
+
+def gaussian_weights(length, offset, sigma):
+    return _CACHE.get(length, offset, sigma)

openscript-0.7.0/openscript/library/history.py

@@ -0,0 +1,72 @@
+"""Immutable contributions with bounded append copying and cheap checkpoints."""
+
+from dataclasses import dataclass
+from typing import Optional, Sequence
+
+from .values import Value
+
+_WIDTH = 32
+
+
+@dataclass(frozen=True, slots=True)
+class _Chunk:
+    values: tuple[Value, ...]
+    prior: Optional["_Chunk"]
+
+
+@dataclass(frozen=True, slots=True)
+class ContributionHistory:
+    """A version shares its sealed prefix with previous versions and forks."""
+
+    head: Optional[_Chunk] = None
+    tail: tuple[Value, ...] = ()
+    count: int = 0
+    maximum: int = 0
+
+    def append(self, value: Value, length: Optional[int]) -> "ContributionHistory":
+        full = len(self.tail) == _WIDTH
+        head = _Chunk(self.tail, self.head) if full else self.head
+        tail = (value,) if full else self.tail + (value,)
+        maximum = max(self.maximum, length or 0)
+        return ContributionHistory(head, tail, self.count + 1, maximum)
+
+    def __deepcopy__(self, memo):
+        """All reachable state is immutable, so checkpoint copying shares it."""
+        return self
+
+    def view(self, length: int) -> "ContributionView":
+        size = min(length, self.count)
+        chunks = []
+        remaining = size - len(self.tail)
+        head = self.head
+        while remaining > 0 and head is not None:
+            chunks.append(head.values)
+            head = head.prior
+            remaining -= _WIDTH
+        return ContributionView(self, tuple(chunks), size)
+
+
+@dataclass(frozen=True, slots=True)
+class ContributionView(Sequence[Value]):
+    """A transient oldest-first sequence indexing only the requested chunks."""
+
+    history: ContributionHistory
+    chunks: tuple[tuple[Value, ...], ...]
+    size: int
+
+    def __len__(self):
+        return self.size
+
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            return [self[at] for at in range(*index.indices(self.size))]
+        if index < 0:
+            index += self.size
+        if index < 0 or index >= self.size:
+            raise IndexError(index)
+        back = self.size - 1 - index
+        tail = self.history.tail
+        if back < len(tail):
+            return tail[len(tail) - 1 - back]
+        before = back - len(tail)
+        return self.chunks[before // _WIDTH][_WIDTH - 1 - before % _WIDTH]

openscript-0.7.0/openscript/library/hypotenuse.py

@@ -0,0 +1,65 @@
+"""Exact two-argument hypotenuse, `stdlib.md` section 20.10.1."""
+import math
+import struct
+
+_LEADING = 1 << 52
+_FRACTION = _LEADING - 1
+
+
+def _parts(value: float) -> tuple[int, int]:
+    encoded = struct.unpack('>Q', struct.pack('>d', abs(value)))[0]
+    exponent = encoded >> 52
+    significand = (encoded & _FRACTION) | (_LEADING if exponent else 0)
+    return significand, exponent - 1075 if exponent else -1074
+
+
+def _decode(encoded: int) -> float:
+    return struct.unpack('>d', struct.pack('>Q', encoded))[0]
+
+
+def _integer_sqrt(value: int) -> int:
+    """Monotone Newton steps from a power-of-two upper bound reach the floor."""
+    if value < 2:
+        return value
+    before = 1 << ((value.bit_length() + 1) // 2)
+    while True:
+        following = (before + value // before) // 2
+        if following >= before:
+            return before
+        before = following
+
+
+def hypotenuse(x: float, y: float) -> float | None:
+    """Round the exact squared sum by comparing with a squared midpoint.
+
+    Binary64 input widths bound every temporary integer to fewer than 4,200 bits.
+    Encoding only after that decision avoids a second rounding through a scale.
+    """
+    if not math.isfinite(x) or not math.isfinite(y):
+        return None
+    if x == 0:
+        return abs(y)
+    if y == 0:
+        return abs(x)
+    a, ea = _parts(x)
+    b, eb = _parts(y)
+    exponent = min(ea, eb)
+    square = (a * a << (2 * (ea - exponent))) + (b * b << (2 * (eb - exponent)))
+    spacing = max(-1074, exponent + (square.bit_length() - 1) // 2 - 52)
+    shift = exponent - spacing
+    numerator = square if shift < 0 else square << (2 * shift)
+    denominator = 1 << (-2 * shift) if shift < 0 else 1
+    significand = _integer_sqrt(numerator // denominator)
+    midpoint = 2 * significand + 1
+    comparison = 4 * numerator - denominator * midpoint * midpoint
+    if comparison > 0 or comparison == 0 and significand % 2:
+        significand += 1
+    if significand >= 2 * _LEADING:
+        significand >>= 1
+        spacing += 1
+    if significand < _LEADING:
+        return _decode(significand)
+    encoded_exponent = spacing + 1075
+    if encoded_exponent >= 2047:
+        return None
+    return _decode(encoded_exponent << 52 | (significand - _LEADING))