basedpl 0.1.70__tar.gz → 0.1.72__tar.gz

{basedpl-0.1.70 → basedpl-0.1.72}/.cargo/config.toml

@@ -12,9 +12,9 @@ MACOSX_DEPLOYMENT_TARGET = "15.0"
 [target.'cfg(target_arch = "x86_64")']
 rustflags = ["-C", "target-cpu=x86-64-v3", "-C", "passes=loop-vectorize,slp-vectorizer"]
 
-# The browser build uses wasm's 128-bit SIMD, which current browsers all support. V8 unrolls loops itself, so LLVM's runtime unrolling is off: under thin LTO it unrolled the vectorized f64 sum's loop twice, which CI's x86 V8 ran about 1.4 times slower.
+# The browser build uses wasm's 128-bit SIMD, which current browsers all support.
 [target.wasm32-unknown-unknown]
-rustflags = ["-C", "target-feature=+simd128", "-C", "passes=loop-vectorize,slp-vectorizer", "-C", "llvm-args=-unroll-runtime=false"]
+rustflags = ["-C", "target-feature=+simd128", "-C", "passes=loop-vectorize,slp-vectorizer"]
 
 [alias]
 # Builds the npm package into `wasm/pkg/`. `xtask` builds optimised, because its wasm-bindgen pass runs on every call.

{basedpl-0.1.70 → basedpl-0.1.72}/.github/workflows/test.yml

@@ -8,31 +8,37 @@ on:
 permissions:
   contents: read
 
+# In each job, every test step after the first runs even when an earlier step fails, to report every test's result in one run.
 jobs:
   test:
     runs-on: ubicloud-standard-4
     steps:
       - uses: actions/checkout@v7
-      - run: node tests/input.mjs
       # `tests/highlighting.mjs` reads the TextMate grammar through `shiki`, which `package.json` pins.
       - run: npm ci
-      - run: node tests/highlighting.mjs
       - uses: dtolnay/rust-toolchain@stable
       # The repository has no `Cargo.lock`. Creating one first makes rust-cache's key change when a dependency publishes a new version.
       - run: cargo generate-lockfile
       - uses: Swatinem/rust-cache@v2
         with:
           shared-key: native
-      # With `BASEDPL_COSTS`, the speed tests here and in the `wasm` job log every case's cost, which `basedpl.bpltests.logged_costs` reads.
-      - run: BASEDPL_COSTS=1 cargo test
       - uses: actions/setup-python@v7
         with:
           python-version: '3.12'
       - run: pip install -e '.[dev]'
       - run: cargo develop
+      - run: node tests/input.mjs
+      - run: node tests/highlighting.mjs
+        if: ${{ !cancelled() }}
+      # With `BASEDPL_COSTS`, the speed tests here and in the `wasm` job log every case's cost, which `basedpl.bpltests.logged_costs` reads.
+      - run: BASEDPL_COSTS=1 cargo test
+        if: ${{ !cancelled() }}
       - run: pytest -q
+        if: ${{ !cancelled() }}
       - run: bpl-nb
+        if: ${{ !cancelled() }}
       - run: nbdev-test
+        if: ${{ !cancelled() }}
 
   wasm:
     runs-on: ubicloud-standard-4
@@ -49,3 +55,4 @@ jobs:
       - run: cargo wasm --strip
       - run: node --test tests/wasm.mjs
       - run: BASEDPL_COSTS=1 node --no-liftoff --test tests/wasm-speed.mjs
+        if: ${{ !cancelled() }}

{basedpl-0.1.70 → basedpl-0.1.72}/Cargo.lock

@@ -93,7 +93,7 @@ checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 
 [[package]]
 name = "basedpl"
-version = "0.1.70"
+version = "0.1.72"
 dependencies = [
  "base64 0.23.1",
  "bytemuck",
@@ -137,7 +137,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-cli"
-version = "0.1.70"
+version = "0.1.72"
 dependencies = [
  "async-trait",
  "basedpl",
@@ -150,7 +150,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-py"
-version = "0.1.70"
+version = "0.1.72"
 dependencies = [
  "basedpl",
  "num-bigint",
@@ -165,7 +165,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-wasm"
-version = "0.1.70"
+version = "0.1.72"
 dependencies = [
  "basedpl",
  "js-sys",
@@ -256,9 +256,9 @@ checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
 
 [[package]]
 name = "cc"
-version = "1.9.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877bf67ac8e52449eb2f9e98a344ea163beb70dd1f9eebe3cc5357dcfeaee4df"
+checksum = "86e055fa6e3e40ad6187ba25b6855eeb635d5271f8e0f0e1e9a5826b8d75bea0"
 dependencies = [
  "find-msvc-tools",
  "shlex",
@@ -303,9 +303,9 @@ dependencies = [
 
 [[package]]
 name = "clipboard-win"
-version = "5.4.1"
+version = "5.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4"
+checksum = "052af7878466feccda12ba7a6a67d019d712f296809559b47c12c8cc196d3a9a"
 dependencies = [
  "error-code",
 ]
@@ -1413,9 +1413,9 @@ dependencies = [
 
 [[package]]
 name = "rustymath"
-version = "0.1.44"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d09b5c088d1b74acc71f0157a144ce1bf8d59884227af80280c531d84d5c0483"
+checksum = "f160fb701304e3888885ade3929ef93b7c7d1aaab5ae61f16c0ec0e01f270cab"
 dependencies = [
  "foldhash",
  "half",
@@ -1434,9 +1434,9 @@ dependencies = [
 
 [[package]]
 name = "rustymath-buffer"
-version = "0.1.44"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c258719e72a8bce7203cdb2d33cfcd989d2b919a176fb78af2c4c9db09ec0fd"
+checksum = "1c1457056dae79ecf521f89d600f82a2a954e601ecd8d478e495b65cb6145010"
 dependencies = [
  "pyo3",
  "rustymath",
@@ -2086,7 +2086,7 @@ checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
 
 [[package]]
 name = "xtask"
-version = "0.1.70"
+version = "0.1.72"
 dependencies = [
  "anyhow",
  "rustymath",

{basedpl-0.1.70 → basedpl-0.1.72}/Cargo.toml

@@ -5,7 +5,7 @@ members = ["py"]
 join_comments = true
 
 [workspace.package]
-version = "0.1.70"
+version = "0.1.72"
 edition = "2024"
 rust-version = "1.98"
 license = "Apache-2.0"

{basedpl-0.1.70 → basedpl-0.1.72}/DEV.md

@@ -184,7 +184,7 @@ Bare numbers, empty literals and NaN use the parsed float width. Top-level `eval
 
 Float operations compute at the wider operand width. Exact operands round to the width an operation computes at. f16 operations run on f32 copies. `Numeric::halving` decides when: for a call with an f16 operand, or any call while the default width is 16 bits. `pervasive::halves` applies it to whole operations and `Number::halves` to scalar arithmetic and comparisons. `fusion::defer` declines those calls. Exact inputs convert once, to f32, and float outputs round back to f16. The scalar `Number` path rounds each f16 step. Complex parts have f32/f64 widths; f16 becoming complex uses f32 parts. Scalar Complex32 arithmetic computes at Complex64 and rounds, while kernels can compute at f32. These paths need not agree in their last bits.
 
-Floats use IEEE NaN, infinity and signed zero. Comparison treats NaN as unequal; match/search treat it as one value, and grade puts it last. Exact arithmetic involving division by zero can produce those float values. Floor/ceiling retain an exact operand beside infinity and give NaN beside NaN. Monadic floor/ceiling/sign turn whole finite results into exact integers, including big integers; nonfinite results remain floats. Use `Number::float(value, width)` and explicit-width array construction outside `number.rs` instead of implicit f64 conversion.
+Floats use IEEE NaN, infinity and signed zero. Comparison treats NaN as unequal; match/search treat it as one value, and grade puts it last. Exact arithmetic involving division by zero can produce those float values. Floor/ceiling retain an exact operand beside infinity. Beside NaN the language leaves their result open: NaN or the other argument, varying by platform. Their folds, scans, windows, products and repeated writes give NaN or the maximum or minimum of the items that aren't NaN, never another number, by the rule in rustymath's `Folds` doc. A loop that folds by them either passes its running result as the right argument, which `rustymath::reduce::maximum` keeps beside NaN, or folds through rustymath's `Max` and `Min`, as `Dyad::extremum` does. Monadic floor/ceiling/sign turn whole finite results into exact integers, including big integers; nonfinite results remain floats. Use `Number::float(value, width)` and explicit-width array construction outside `number.rs` instead of implicit f64 conversion.
 
 Under `•prefs ["kinds":"static"]`, a result's kind follows from its arguments' kinds alone, as `meta/kinds.md` describes. `Numeric` carries `kinds` and `int`. `pervasive::map` chooses a dyadic call's kind through `joined`, which applies rustymath's `DType::common` after `Numeric::kind`. Atoms promote as arrays do. Python's API makes its scalar arguments weak through `Value::weakened`. The loops keep the failed results that `keeps` names: floats' NaNs, and the wrapped integers of objects that report `WRAPS`. The kernel tables choose float `⌊ ⌈ ×` and wrapping negation from `run.numeric()`. `Stored::build_at` keeps complex results complex. `Primitive::number` gives every pervasive result on numbers, as well as each step of the fold of numbers, and `statically` adjusts it. `Number::parse` keeps complex literals and checks integer literals against the `int` width.
 

{basedpl-0.1.70 → basedpl-0.1.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basedpl
-Version: 0.1.70
+Version: 0.1.72
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: fastcore

{basedpl-0.1.70 → basedpl-0.1.72}/nbs/glyphs/downstile.qmd

@@ -15,12 +15,10 @@ Complex floor uses APL's Gaussian-integer rule.
 ⌊1.5j0.5          ⍝ 1j1
 ```
 
-`X⌊Y` takes the real minimum, and for characters the one with the lower code point. A number is less than any character, as [`⍋`](delta-stile.qmd) orders them. Pervasive. A NaN beside any number gives NaN, in either order and on every machine. A reduction or scan gives NaN from its first NaN on. To leave NaNs out, remove them first, as in `⌊/(v=v)#v`. Empty reduction identity: `∞`.
+`X⌊Y` takes the real minimum, and for characters the one with the lower code point. A number is less than any character, as [`⍋`](delta-stile.qmd) orders them. Pervasive. Beside NaN it gives NaN or the other argument. Which one can vary by platform. A reduction, scan, window or inner product by `⌊`, or a write by `⌊←` to one position more than once, gives NaN or the least of the items that aren't NaN, and never another number. Empty reduction identity: `∞`.
 
 ```bpl
 3⌊1 5             ⍝ 1 3
-3⌊1 $n 5          ⍝ 1 $n 3
-⌊\1 $n 3          ⍝ 1 $n $n
 "abc"⌊"bab"       ⍝ "aab"
 3⌊'a'             ⍝ 3
 ```

{basedpl-0.1.70 → basedpl-0.1.72}/nbs/glyphs/upstile.qmd

@@ -9,12 +9,10 @@ Function. Keys: `Alt-s`. Hanzi: `上`. Ranks: `0` monadic, `0 0` dyadic
 ⌈3r2              ⍝ 2ₓ
 ```
 
-`X⌈Y` takes the real maximum, and for characters the one with the higher code point. A character is greater than any number, as [`⍋`](delta-stile.qmd) orders them. Pervasive. A NaN beside any number gives NaN, in either order and on every machine. A reduction or scan gives NaN from its first NaN on. To leave NaNs out, remove them first, as in `⌈/(v=v)#v`. Empty reduction identity: `¯∞`.
+`X⌈Y` takes the real maximum, and for characters the one with the higher code point. A character is greater than any number, as [`⍋`](delta-stile.qmd) orders them. Pervasive. Beside NaN it gives NaN or the other argument. Which one can vary by platform. A reduction, scan, window or inner product by `⌈`, or a write by `⌈←` to one position more than once, gives NaN or the greatest of the items that aren't NaN, and never another number. Empty reduction identity: `¯∞`.
 
 ```bpl
 3⌈1 5             ⍝ 3 5
-3⌈1 $n 5          ⍝ 3 $n 5
-⌈\1 $n 3          ⍝ 1 $n $n
 "abc"⌈"bab"       ⍝ "bbc"
 3⌈'a'             ⍝ 'a'
 ```

{basedpl-0.1.70 → basedpl-0.1.72}/nbs/numbers.qmd

@@ -199,14 +199,13 @@ An infinity or NaN is a float. Joining one to exact integers makes them floats,
 
 CSV and JSON imports give NaN for a missing number. An integer column with gaps then becomes floats. A column that also holds an integer too large for a float to hold exactly keeps each item's kind, in mixed storage.
 
-`⌊` and `⌈` return an exact argument unchanged beside an infinity. Beside NaN they give NaN:
+`⌊` and `⌈` return an exact argument unchanged beside an infinity:
 
 ```bpl
 3ₓ⌊∞                 ⍝ 3ₓ
-3ₓ⌊$n                ⍝ $n
 ```
 
-Arithmetic with an infinity gives floats.
+The [`⌈`](glyphs/upstile.qmd) and [`⌊`](glyphs/downstile.qmd) pages give their results beside NaN. Arithmetic with an infinity gives floats.
 
 ## Static kinds
 

{basedpl-0.1.70 → basedpl-0.1.72}/py/src/lib.rs

@@ -208,7 +208,7 @@ fn selection(value: &Value, index: &Bound<'_, PyAny>, convert: &Bound<'_, PyAny>
         match v {
             None => Some(rustymath_buffer::selection::selector(layout, axis, p, || unreachable!("a native selector decodes without converting"))),
             Some(v) => match v.view() {
-                Some(mask @ View::Booleans(_)) => Some(rustymath_buffer::selection::array_selector(layout, axis, v.core_layout().clone(), mask, false)),
+                Some(View::Booleans(_)) => Some(rustymath_buffer::selection::array_selector(layout, axis, v.core_layout().clone(), std::sync::Arc::new(v.clone()))),
                 _ => None,
             },
         }

{basedpl-0.1.70 → basedpl-0.1.72}/python/basedpl/bpltests.py

@@ -2,6 +2,7 @@
 import json, math, os, re, statistics, subprocess, sys, tempfile, time, tomllib
 from concurrent.futures import ThreadPoolExecutor
 from collections import defaultdict
+from itertools import accumulate
 from decimal import Context, Decimal, ROUND_CEILING
 from dataclasses import dataclass, field, replace
 from pathlib import Path
@@ -336,7 +337,8 @@ def instructions(
     def steps(code):
         if counts: return counts
         rough = max(1, (count(code, 1_000, 1) - count(code, 0, 1)) / 1_000)
-        return [round((_SETTLE + i*_SPAN)/rough) for i in range(4)]
+        # Each value is at least one more than the last, for a case that retires more than `_SPAN` instructions a step, whose warm-up is then a small share of a step.
+        return list(accumulate((round((_SETTLE + i*_SPAN)/rough) for i in range(4)), lambda last, n: max(n, last + 1)))
     def per_step(code):
         ns = steps(code)
         cs = [count(code, n) for n in ns]

{basedpl-0.1.70 → basedpl-0.1.72}/src/batch.rs

@@ -31,6 +31,8 @@ impl Batch {
     pub(crate) fn rank(&self) -> usize { self.whole.shape().len() - self.frame }
     /// The number of cells: the product of the frame's lengths.
     pub(crate) fn cells(&self) -> usize { self.whole.shape()[..self.frame].iter().product() }
+    /// The array that holds every cell, with the frame's axes first.
+    pub(crate) fn whole(&self) -> &Value { &self.whole }
     /// The frame's layout: the whole's first `frame` axes, with their keys and names.
     fn frame_layout(&self) -> Layout { self.whole.layout().axes(0..self.frame) }
     /// One `Steps` for each frame axis, reading item `start` of each cell of the whole, cell by cell.

{basedpl-0.1.70 → basedpl-0.1.72}/src/derivative.rs

@@ -806,7 +806,7 @@ fn product_dual(left: &Value, right: &Value, tag: u64, stacked: bool, span: &Spa
 
 /// The primal and tangent of a fold or scan by `p`, which is `×`, `⌈` or `⌊`, of `x` with tangent `tx`, through the linear operations that reverse mode transposes. A product's tangent scales each item's tangent by the product of the others and sums: the product of the nonzero items, times the sum of `tx÷x` where no item is zero, or times the zero item's tangent where one is, and 0 where more are. A maximum's or minimum's tangent gathers the tangent of the item that gives it, the first of any ties, as dyadic `⌈` and `⌊` give a tie to their left argument.
 fn fold_rule(p: Primitive, kind: FoldKind, axis: Option<usize>, x: &Value, tx: &Value, span: &Span) -> Result<(Value, Value), Error> {
-    use {crate::array::Lanes, Arithmetic::*, Comparison::{Equal, NotEqual}};
+    use {crate::array::Lanes, Arithmetic::*, Comparison::Equal};
     let call = |p: Primitive, a: &Value, b: &Value, span: &Span| p.call(Some(a), b, span);
     let fold = |p: Primitive, v: &Value| Operation::Fold(p, kind).call(Pairing::Axis(axis), None, v, span);
     let (times, plus) = (Primitive::Arithmetic(Times), Primitive::Arithmetic(Plus));
@@ -823,51 +823,35 @@ fn fold_rule(p: Primitive, kind: FoldKind, axis: Option<usize>, x: &Value, tx: &
         let one = call(times, &call(times, &rest, &call(Primitive::Compare(Equal), &zeros, &Value::integer(1), span)?, span)?, &one, span)?;
         call(plus, &none, &one, span)?
     } else {
-        let shape = x.shape();
-        let along = axis.unwrap_or(kind.default_axis(shape.len()));
-        let lanes = Lanes::new(shape, along)?;
-        let Lanes { outer, len: n, inner } = lanes;
-        let booleans = |v: Value| v.as_booleans().map(<[bool]>::to_vec).unwrap_or_else(|| v.elements().map(|e| matches!(e, Value::Number(n) if !n.is_zero())).collect());
-        let (offsets, one_per_lane) = if kind.scan {
-            // A running maximum or minimum changes only where an item gives a new extreme, whose tangent it then follows. Where it doesn't change, the earlier item keeps it.
-            let drop = |d: i64, span: &Span| {
-                let spec = Value::integers(vec![along + 1], (0..=along).map(|a| if a == along { d } else { 0 }).collect()).described("invalid drop")?;
-                Primitive::Drop.call(Some(&spec), &r, span)
-            };
-            let changed = booleans(call(Primitive::Compare(NotEqual), &drop(1, span)?, &drop(-1, span)?, span)?);
-            let mut offsets = Vec::with_capacity(outer * n * inner);
-            for o in 0..outer {
-                for k in 0..n {
-                    for i in 0..inner {
-                        let at = lanes.offset(o, k, i);
-                        offsets.push(if k == 0 || changed[(o * (n - 1) + k - 1) * inner + i] { at as i64 } else { offsets[at - inner] });
-                    }
-                }
+        let along = axis.unwrap_or(kind.default_axis(x.shape().len()));
+        // One pick on a batch's whole, with the frame's axes first, serves every cell. A batch's scan stops the run, and its map calls the operand once for each cell, because a scan's tangent gathers at each cell's own positions.
+        let batch = x.carrier().and_then(Carrier::batch);
+        if let (Some(b), true) = (batch, kind.scan) { return Err(Stop::new(b.level, Cause::Rule).into()); }
+        let all = batch.map_or(x, |b| b.whole());
+        let lanes = Lanes::new(all.shape(), batch.map_or(0, |b| b.frame) + along)?;
+        // Windows that slide along the fold's axis give their extremes' positions from their source, with no windows built.
+        let windows = (batch.is_none() && along == kind.default_axis(x.shape().len())).then(|| crate::fusion::picks(x, p, kind)).flatten();
+        let one_per_lane = !kind.scan && windows.is_none();
+        let offsets = match windows {
+            Some(offsets) => offsets,
+            None => {
+                let Lanes { outer, len: n, inner } = lanes;
+                let numbers = || Error::domain("∂ takes ⌈ and ⌊ of numbers");
+                // Mixed storage picks among its numbers as floats. Two different exact integers beyond 2⁵³ can round to one float. They then tie, and the earlier one is picked.
+                let floats = match all.view() { Some(_) => None, None => Some(all.to_float_width(FloatWidth::F64).map_err(|_| numbers())?) };
+                let view = floats.as_ref().unwrap_or(all).view().ok_or_else(numbers)?;
+                let of = if kind.scan { rustymath::reduce::Picks::Running } else { rustymath::reduce::Picks::Lanes };
+                let rows = crate::pervasive::picks(p, view, [outer, n, inner], of).ok_or_else(numbers)?;
+                // Each running fold's pick, or each lane's, as a position in the ravel.
+                rows.into_iter().enumerate().map(|(j, row)| lanes.offset(if kind.scan { j / (n * inner) } else { j / inner }, row, j % inner) as i64).collect()
             }
-            (offsets, false)
-        } else if let Some(offsets) = (along == kind.default_axis(shape.len())).then(|| crate::fusion::picks(x, p, kind)).flatten() {
-            // Windows that slide along the fold's axis give their extremes' positions from their source, with no windows built.
-            (offsets, false)
-        } else {
-            // `r` takes a length-1 axis in place of the folded axis to pair with `x`, unless the fold removed the last axis.
-            let back = if along + 1 < shape.len() {
-                let mut shape = r.shape().iter().map(|&n| n as i64).collect::<Vec<_>>();
-                shape.insert(along, 1);
-                Primitive::Shape.call(Some(&Value::integers(vec![shape.len()], shape).described("invalid shape")?), &r, span)?
-            } else { r.clone() };
-            let hit = booleans(call(Primitive::Compare(Equal), x, &back, span)?);
-            // The first item of each lane that gives its extreme, or the lane's first item where none does, as for NaN.
-            let firsts = (0..outer)
-                .flat_map(|o| (0..inner).map(move |i| (o, i)))
-                .map(|(o, i)| (0..n).map(|k| lanes.offset(o, k, i)).find(|&at| hit[at]).unwrap_or(lanes.offset(o, 0, i)) as i64)
-                .collect::<Vec<_>>();
-            (firsts, true)
         };
-        // Where reverse mode records one item from each lane, the tangent folds the tangent times a mask of the chosen items. Its transpose reads: each item takes its lane's cotangent where it was chosen, and 0 elsewhere. A gather's transpose would scatter.
-        if one_per_lane && tx.carried() {
-            let mut chosen = vec![false; x.len()];
+        // Where reverse mode records one item from each lane, or `x` is a batch, the tangent folds the tangent times a mask of the chosen items. Its transpose reads: each item takes its lane's cotangent where it was chosen, and 0 elsewhere. A gather's transpose would scatter.
+        if one_per_lane && (tx.carried() || batch.is_some()) {
+            let mut chosen = vec![false; all.len()];
             for &at in &offsets { chosen[at as usize] = true; }
-            let mask = x.layout().booleans(chosen).described("invalid mask")?;
+            let mask = all.layout().booleans(chosen).described("invalid mask")?;
+            let mask = match batch { Some(b) => crate::batch::batch(b.level, mask, b.frame), None => mask };
             return Ok((r, fold(plus, &call(times, &mask, tx, span)?)?));
         }
         let offsets = Value::integers(vec![offsets.len()], offsets).described("invalid positions")?.enclose().expect("positions enclose");

{basedpl-0.1.70 → basedpl-0.1.72}/src/eval/bindings.rs

@@ -357,12 +357,12 @@ impl Bindings {
 
     /// Pushes `frame` and makes it current. Its first slots hold `implicit`, the bindings of the six names that a call binds itself, in slot order (`Name::implicit`), and its locals' slots are empty. Fails at the depth limit, before pushing.
     #[inline]
-    pub(super) fn enter(&self, mut frame: Frame, implicit: [Option<Binding>; IMPLICIT], span: &Span) -> Result<(), Error> {
+    pub(super) fn enter(&self, mut frame: Frame, mut implicit: [Option<Binding>; IMPLICIT], span: &Span) -> Result<(), Error> {
         let mut stack = self.stack.borrow_mut();
         if stack.frames.len() == MAX_FRAME_DEPTH { return Err(Error::new(Kind::Limit, format!("lexical frame depth exceeds {MAX_FRAME_DEPTH}")).at(span)); }
         frame.base = stack.slots.len();
-        stack.slots.extend(implicit);
         stack.slots.resize_with(frame.slots().end, || None);
+        stack.slots[frame.base..frame.base + IMPLICIT].swap_with_slice(&mut implicit);
         self.current.set(Some(stack.frames.len()));
         stack.frames.push(frame);
         Ok(())

{basedpl-0.1.70 → basedpl-0.1.72}/src/eval/operators.rs

@@ -1612,14 +1612,14 @@ pub(crate) fn primitive_fold(p: Primitive, kind: FoldKind, axis: Option<usize>,
     let active = crate::transform::carried(None, right);
     let (along, plan) = FoldPlan::new(kind, axis, seed, right, || identity(p, &right.prototype(), span))?;
     let result = match plan {
-        FoldPlan::One(item) => match seed { Some(seed) if kind.scan => call(seed, &item)?, Some(seed) => call(&item, seed)?, None => lone(item) },
+        FoldPlan::One(item) => match seed { Some(seed) if kind.scan => scan_step(p, call)(seed, &item)?, Some(seed) => call(&item, seed)?, None => lone(item) },
         FoldPlan::Whole => lone(right.clone()),
         FoldPlan::Done(result) => result,
         FoldPlan::Lanes { lanes, shape } if kind.scan => {
             if let Some(result) = (!active).then(|| crate::pervasive::scan(p, right, seed, &lanes)).flatten() { result }
             else if let (Primitive::Arithmetic(op), false, true) = (p, active, right.all_numbers() && seed.is_none_or(|a| matches!(a, Value::Number(_)))) {
                 number_lanes(op, true, right, seed, &lanes, shape)?
-            } else { item_lanes(true, &lanes, shape, seed, right, call, active)? }
+            } else { item_lanes(true, &lanes, shape, seed, right, scan_step(p, call), active)? }
         }
         FoldPlan::Lanes { lanes, shape } => {
             // Where `p`'s kernel folds in any order, a number seed joins each lane's result after the fold, as one more item would. The fold then takes the fusion and kernel routes of a fold with no seed. A level that carries `right` keeps the seed in its items, because its kernels don't apply there. So do Booleans under a `ᵇ` table that `sets_high_bits`: they fold by the logical function, and a number seed turns the fold to the integer function.
@@ -1672,7 +1672,7 @@ fn number_lanes(
     let (item, seed) = (|i| number(right.at(i)), seed.cloned().map(number));
     let (p, t) = (Primitive::Arithmetic(op), Numeric::current());
     let step = |x: &crate::Number, y: &crate::Number| { check()?; p.number(Some(x), y, t).map_err(Error::from) };
-    let data = if scan { scan_items(axis, seed, item, step)? } else { fold_items(axis, seed.as_ref(), item, step)? };
+    let data = if scan { scan_items(axis, seed, item, scan_step(p, step))? } else { fold_items(axis, seed.as_ref(), item, step)? };
     Value::new(shape, data.into_iter().map(Value::Number).collect()).described("invalid numeric result")
 }
 
@@ -1690,6 +1690,13 @@ fn fold_items<T: Clone>(axis: &Lanes, seed: Option<&T>, item: impl Fn(usize) ->
     Ok(data)
 }
 
+/// `apply` as a step of `p`'s scan, which takes the running result and the next item in the order that keeps rustymath's rule beside NaN. `⌈` and `⌊` take the item on the left, because a maximum or minimum keeps its right argument beside NaN. Every other function takes the running result on the left, as a scan from the left does.
+fn scan_step<V>(p: Primitive, mut apply: impl FnMut(&V, &V) -> Result<V, Error>) -> impl FnMut(&V, &V) -> Result<V, Error> {
+    let turned = matches!(p, Primitive::Math(crate::number::Math::Ceiling | crate::number::Math::Floor));
+    move |total, item| if turned { apply(item, total) } else { apply(total, item) }
+}
+
+/// Each lane of `axis` scanned from the left, starting from `seed` or else the lane's first item: `apply(result, item)`.
 fn scan_items<T: Clone>(axis: &Lanes, seed: Option<T>, item: impl Fn(usize) -> T, mut apply: impl FnMut(&T, &T) -> Result<T, Error>) -> Result<Vec<T>, Error> {
     let mut data = vec![item(0); axis.outer * axis.len * axis.inner];
     for i in 0..axis.outer {

{basedpl-0.1.70 → basedpl-0.1.72}/src/eval/session.rs

@@ -617,11 +617,10 @@ impl Session {
 
     // Inlined into `dispatch`, this would add its locals to the stack frame of every BPL call, limiting recursion in the browser.
     #[inline(never)]
-    pub(super) fn call_defined(&self, function: &Function, left: Option<&Value>, right: &Value) -> Result<Bound, Error> {
-        let return_span = function.definition().expect("call_defined calls a dfn").span.clone();
+    pub(super) fn call_defined(&self, first: &Function, left: Option<&Value>, right: &Value) -> Result<Bound, Error> {
         let caller = self.bindings.current();
         let base = self.bindings.depth();
-        let (mut function, mut left, mut right) = (function.clone(), left.cloned(), right.clone());
+        let (mut function, mut left, mut right) = (first.clone(), left.cloned(), right.clone());
         let mut tail_span = None;
         let mut unshy = false;
         let mut result = loop {
@@ -653,7 +652,7 @@ impl Session {
         };
         if let (Err(error), Some(span)) = (&mut result, tail_span) { error.calls.push(span); }
         if let Ok(bound) = &mut result { if unshy { bound.shy = false; } }
-        self.leave(base, caller, result, &return_span)
+        self.leave(base, caller, result, &first.definition().expect("call_defined calls a dfn").span)
     }
 
     /// Drops the frames from `base` on, makes `caller` current and gives back `result`. A result that refers to a dropped frame is an error.

{basedpl-0.1.70 → basedpl-0.1.72}/src/fusion.rs

@@ -486,7 +486,7 @@ pub(crate) fn picks(value: &Value, p: Primitive, kind: FoldKind) -> Option<Vec<i
     let shape = value.shape();
     let (_, tables) = w.folded(shape, k, width);
     if !Steps::in_order(&tables) { return None; }
-    let rows = pervasive::sliding_picks(p, w.region()?, w.rows, width)?;
+    let rows = pervasive::picks(p, w.region()?, w.rows, rustymath::reduce::Picks::Windows(width))?;
     // Each window starts at the position along `q` that the copy's other axes along `q` reach. Its pick lies that many rows before.
     let strides = strides(shape);
     let rest: Vec<usize> = (0..shape.len()).filter(|&r| r != k).collect();

{basedpl-0.1.70 → basedpl-0.1.72}/src/number.rs

@@ -883,7 +883,7 @@ impl Number {
 
     fn minimum(&self, right: &Self, maximum: bool) -> Result<Self, &'static str> {
         if let (Integer(x), Integer(y)) = (&self.0, &right.0) { return Ok(Self(Integer(if maximum { *x.max(y) } else { *x.min(y) }))); }
-        // NaN beside any number gives NaN, at the width the two compute at. An exact number stays exact beside an infinity, and beside another exact number.
+        // Beside NaN it gives `right` at the width the two compute at, as `rustymath::reduce::maximum` gives its `y`. An exact number stays exact beside an infinity, and beside another exact number.
         let nan = self.is_nan() || right.is_nan();
         if !nan && ((self.is_exact() && right.is_exact()) || self.is_infinite() || right.is_infinite()) {
             return Ok((if maximum == self.order(right)?.is_lt() { right } else { self }).clone());