basedpl 0.1.69__tar.gz → 0.1.71__tar.gz

{basedpl-0.1.69 → basedpl-0.1.71}/.github/workflows/ci.yml

@@ -38,9 +38,7 @@ jobs:
       - name: Time the release build
         continue-on-error: true
         timeout-minutes: 20
-        run: |
-          echo "model name : $(if [ "$RUNNER_OS" = macOS ]; then sysctl -n machdep.cpu.brand_string; else lscpu | sed -n 's/^Model name: *//p' | head -1; fi)"
-          bin/${{ matrix.binary }} --costs tests/speed.txt
+        run: bin/${{ matrix.binary }} --costs tests/speed.txt
       - uses: actions/upload-artifact@v7
         with:
           name: wheels-${{ matrix.os }}

{basedpl-0.1.69 → basedpl-0.1.71}/.github/workflows/speed.yml

@@ -16,7 +16,6 @@ jobs:
           python-version: '3.12'
       # This job times the `bpl` that releases ship, which `cargo stage --profile dist` builds, as the `Release` workflow does. `bpl --costs` prints every case's cost and budget for `basedpl.bpltests.logged_costs`. A case over its budget doesn't fail it. The job builds without a cache. The `Test` workflow's caches hold only test-profile builds.
       - run: pip install 'fastws-cli>=0.0.25' && cargo stage --profile dist
-      - run: grep -m1 'model name' /proc/cpuinfo
       - run: wheel/scripts/bpl --costs tests/speed.txt
       # `bpl-tests thread_scaling` times a large product, a 512×512 SVD and Hermitian eigendecomposition, a stack of QR decompositions and a large elementwise function on one thread and on the runner's cores, and fails when one speeds up less than 1.5 times. Speed budgets are single-thread measurements, so this is the check of multithreaded speed. It comes last, so that a failure here still leaves every cost logged.
       - run: pip install -e . && bpl-tests thread_scaling --bpl wheel/scripts/bpl
@@ -33,5 +32,4 @@ jobs:
         with:
           shared-key: wasm
       - run: cargo wasm --strip
-      - run: grep -m1 'model name' /proc/cpuinfo
       - run: BASEDPL_COSTS=1 node --no-liftoff tests/wasm-speed.mjs

{basedpl-0.1.69 → basedpl-0.1.71}/.github/workflows/test.yml

@@ -23,7 +23,6 @@ jobs:
       - uses: Swatinem/rust-cache@v2
         with:
           shared-key: native
-      - run: grep -m1 'model name' /proc/cpuinfo
       # 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
@@ -49,5 +48,4 @@ jobs:
           shared-key: wasm
       - run: cargo wasm --strip
       - run: node --test tests/wasm.mjs
-      - run: grep -m1 'model name' /proc/cpuinfo
       - run: BASEDPL_COSTS=1 node --no-liftoff --test tests/wasm-speed.mjs

{basedpl-0.1.69 → basedpl-0.1.71}/Cargo.lock

@@ -93,7 +93,7 @@ checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 
 [[package]]
 name = "basedpl"
-version = "0.1.69"
+version = "0.1.71"
 dependencies = [
  "base64 0.23.1",
  "bytemuck",
@@ -137,7 +137,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-cli"
-version = "0.1.69"
+version = "0.1.71"
 dependencies = [
  "async-trait",
  "basedpl",
@@ -150,7 +150,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-py"
-version = "0.1.69"
+version = "0.1.71"
 dependencies = [
  "basedpl",
  "num-bigint",
@@ -165,7 +165,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-wasm"
-version = "0.1.69"
+version = "0.1.71"
 dependencies = [
  "basedpl",
  "js-sys",
@@ -1413,9 +1413,9 @@ dependencies = [
 
 [[package]]
 name = "rustymath"
-version = "0.1.43"
+version = "0.1.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47219acf94cb55feca56bf23818d8d1c013a17fd63023721e6edac118c065629"
+checksum = "539dbd536cc6c64e9080a2c0bc346b6cf2f5308f0e29f814bfefd244bce87d07"
 dependencies = [
  "foldhash",
  "half",
@@ -1434,9 +1434,9 @@ dependencies = [
 
 [[package]]
 name = "rustymath-buffer"
-version = "0.1.43"
+version = "0.1.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6991cc5072aadb4af88d88526fb6479f59f9641b86fd6f10b7a407b8e02bd6e4"
+checksum = "1b3f549d927a69037ffe1ec3d11a318d89bbb115ac26c071d19150207e62a811"
 dependencies = [
  "pyo3",
  "rustymath",
@@ -2086,7 +2086,7 @@ checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
 
 [[package]]
 name = "xtask"
-version = "0.1.69"
+version = "0.1.71"
 dependencies = [
  "anyhow",
  "rustymath",

{basedpl-0.1.69 → basedpl-0.1.71}/Cargo.toml

@@ -5,14 +5,14 @@ members = ["py"]
 join_comments = true
 
 [workspace.package]
-version = "0.1.69"
+version = "0.1.71"
 edition = "2024"
 rust-version = "1.98"
 license = "Apache-2.0"
 
 [workspace.dependencies]
-rustymath = { version = ">=0.1.43, <1", default-features = false }
-rustymath-buffer = ">=0.1.43, <1"
+rustymath = { version = ">=0.1.44, <1", default-features = false }
+rustymath-buffer = ">=0.1.44, <1"
 pyo3 = ">=0.29.2, <1"
 pyo3-build-config = ">=0.29.2, <1"
 

{basedpl-0.1.69 → basedpl-0.1.71}/DEV.md

@@ -26,19 +26,19 @@ When another agent's unfinished edits stop the shared tree compiling, run `cargo
 
 An already-running Python process retains its loaded extension. In a kernel, use `from basedpl.worker import fresh; fresh(code)` to check the installed `bpl` in a fresh worker instead of restarting the kernel. A BPL error raises `BplError`. `fresh(code, bpl=PATH)` runs a saved copy of `bpl`, such as the baseline described below. Check one expression and read its result before building on it. `basedpl.bpltests.check_file` and `check_page` check reference files and documentation through the worker without building Rust. With `bpl=PATH`, they check a saved copy without installing it.
 
-Measure with `BASEDPL_COSTS=1 cargo test --test speed` or `basedpl.bpltests.time_cases(cases)`. Both count costs in copies. A copy is the time to write as many floats as the data has items, each negated, into a second buffer, with both in cache. `rustymath::timing::COPIES` stores the copy time of each machine that runs the speed tests, by its CPU, the item's size and the number of items, at the slower end of what that copy normally takes. A copy timed beside each case varied more than 3 times on CI's runner, where the functions' own times didn't, so stored times keep that noise out of every cost. On a machine or a size with no entry, the test measures the copy once and prints a line to add to `COPIES`. Each case's line in a log ends with its time for each item, and the log has a copy line for each size of data, which `logged_costs` reads into its result's `copies`. Budgets are single-thread measurements. `thread_scaling()` checks multithreaded speed: it times a large product, a 512×512 SVD and Hermitian eigendecomposition, a stack of QR decompositions and a large elementwise function on one thread and on the machine's cores, and fails when one speeds up less than 1.5 times. Accelerate's GESDD and SYEVD run on one thread whatever its threading setting. On macOS, where Accelerate computes the product, the SVD and the Hermitian eigendecomposition, those three cases need only the speedups in `_ACCELERATED_LEAST`. The manual `Speed` workflow runs it. `speed_costs()` reads the cases in `tests/speed.txt`. `cases=` selects expressions, `wasm=DIR` selects a browser build, `bpl=PATH` selects another native `bpl`, such as a saved copy, and `native=True` times rustymath's own linear algebra, which dev builds compile in. `logged_costs(log)` reads CI output from its text or a file. `cargo_costs(path)` runs either project's Rust speed test, and `pytest_costs(path)` runs rustymath's Python speed test.
+Measure with `BASEDPL_COSTS=1 cargo test --test speed` or `basedpl.bpltests.time_cases(cases)`. Both count costs in copies. A copy is the time to write as many floats as the data has items, each negated, into a second buffer. `rustymath::timing::COPIES` stores the copy time of each machine that runs the speed tests, by its CPU, the item's size and the number of items, at the slower end of what that copy normally takes, for copies whose source and destination fit in cache, 64 MiB together (`CACHED_BYTES`). A copy timed beside each case varied more than 3 times on CI's runner, where the functions' own times didn't, so stored times keep that noise out of every cost. A larger copy runs at the speed of memory, which a shared runner varies by up to 2 times between runs, and the cases of that size vary with it. The test measures such a copy once in each run. It also measures a cached size with no entry once, and prints a line to add to `COPIES`. The browser build has entries of its own, for its copy under the JavaScript engine. It can't read the CPU's name, and `tests/wasm-pkg.mjs` passes it the name that Node reads. Each case's line in a log ends with its time for each item, which `logged_costs` keeps in each row, and the log has a copy line for each size of data, which it reads into its result's `copies`. Budgets are single-thread measurements. `thread_scaling()` checks multithreaded speed: it times a large product, a 512×512 SVD and Hermitian eigendecomposition, a stack of QR decompositions and a large elementwise function on one thread and on the machine's cores, and fails when one speeds up less than 1.5 times. Accelerate's GESDD and SYEVD run on one thread whatever its threading setting. On macOS, where Accelerate computes the product, the SVD and the Hermitian eigendecomposition, those three cases need only the speedups in `_ACCELERATED_LEAST`. The manual `Speed` workflow runs it. `speed_costs()` reads the cases in `tests/speed.txt`. `cases=` selects expressions, `wasm=DIR` selects a browser build, `bpl=PATH` selects another native `bpl`, such as a saved copy, and `native=True` times rustymath's own linear algebra, which dev builds compile in. `logged_costs(log)` reads CI output from its text or a file. `cargo_costs(path)` runs either project's Rust speed test, and `pytest_costs(path)` runs rustymath's Python speed test.
 
-Costs in copies can't show a per-call change of a few percent, because code layout alone moves a timing by more than that. `instructions(cases)` counts instructions, which load and layout don't change. Each case is BPL that makes one call per step of `N`, such as `{⍵}⍣N⊢0`. A map such as `f¨N⍴0` calls a dfn once on all its cells, so it gives no per-call cost. It runs fresh single-threaded `bpl` processes at four values of `N`. For each pair of successive values, it divides the difference in instructions retired by the difference in `N`, which cancels startup and `setup=`, and it reports the median of those three slopes. The median drops a one-off cost that starts once `N` passes some size, because such a cost falls between only one pair. `≢•ucs N⍴"ab" "cde"` has one: it retires about 5×10⁶ more instructions from about 131,350 items on. Every value of `N` lies past the warm-up, from a rough count at 1,000 steps, because a case that allocates an array at each step retires extra instructions over its first steps while the allocator settles. Each process pays a different warm-up, up to about 5×10⁶ instructions, so successive values of `N` lie 5×10⁸ instructions apart, where that difference moves a slope by under 1%. `counts=` sets two or more values instead. It reads `/usr/bin/time -l` on macOS and `perf stat` on Linux, and `bpl=PATH` counts a saved copy. A case that only drops a structural result that stays pending, such as large windows or a transpose, counts making the pending copy, not the copy: `{⍵⊣3↕v}⍣N⊢0` retires about 15,000 instructions a step. An indexed write computes the whole array first. `{x←3↕v ⋄ x.[0]←0 ⋄ ⍵}⍣N⊢0` counts the copy itself, about 12 million instructions a step. A join computes at once and needs no write.
+Costs in copies can't show a per-call change of a few percent, because code layout alone moves a timing by more than that. `instructions(cases)` counts instructions, which load and layout don't change. Each case is an expression, such as `k(⌈/⊢)⌸a`, run once per step inside `{case ⋄ ⍵}⍣N⊢0`. That dfn's own call adds about 1,900 instructions a step. A case that names `N` makes its own calls instead, such as `{⍵}⍣N⊢0`, which makes one dfn call a step. Such a case must make one call per step: a map such as `f¨N⍴0` calls a dfn once on all its cells, so it gives no per-call cost. It runs fresh single-threaded `bpl` processes at four values of `N`. For each pair of successive values, it divides the difference in instructions retired by the difference in `N`, which cancels startup and `setup=`, and it reports the median of those three slopes. The median drops a one-off cost that starts once `N` passes some size, because such a cost falls between only one pair. `≢•ucs N⍴"ab" "cde"` has one: it retires about 5×10⁶ more instructions from about 131,350 items on. Every value of `N` lies past the warm-up, from a rough count at 1,000 steps, because a case that allocates an array at each step retires extra instructions over its first steps while the allocator settles. Each process pays a different warm-up, up to about 5×10⁶ instructions, so successive values of `N` lie 5×10⁸ instructions apart, where that difference moves a slope by under 1%. `counts=` sets two or more values instead. It reads `/usr/bin/time -l` on macOS and `perf stat` on Linux, and `bpl=PATH` counts a saved copy. A case whose result stays pending, such as large windows or a transpose, counts making the pending copy, not the copy: `3↕v` retires about 12,000 instructions a step. `force=True` computes each step's result in full, through an indexed write, for any result of rank 1 or more: `3↕v` then counts the copy itself, about 9 million instructions a step. A join computes at once and needs no `force`.
 
 `tests/instructions.txt` holds the instructions that each case retires for each step, as counted on macOS on Apple silicon. Most cases make one call per step, from `{⍵}⍣N⊢0` to `fib`. Three map a function over the same 64 cells each step, through Each, Rank's general path and a system function's own item map. `instruction_budgets()` counts each case through `instructions` and marks a case `over` when it retires more than 3% above its count, and `stale` when it retires more than 3% below it. `tests/test_instructions.py` fails on either mark, and skips on other platforms. The change that makes a call cheaper also lowers each count it moves. A new compiler version can inline differently and move the counts, and then they're set again from `bpl-tests instruction_budgets`. CI checks only the speed budgets.
 
-`profile(case)` shows where a case's instructions go, by function, on macOS. A fresh process repeats the case on one thread while `sample` counts how often each function is at the top of the main thread's stack. A function's share of those samples, times the build's count from `instructions`, estimates its instructions per step. The estimate assumes every function retires instructions at the same rate. When a count moves, `profile_diff(case, base)` shows which functions moved it, from those estimates for both builds. A function that one build inlines and the other calls out of line appears under one build alone. Run them before reading machine code. `base` is a saved copy, and `bpl=PATH` sets the build to profile, the installed one by default.
+`profile(case)` shows where a case's instructions go, by function, on macOS. It takes a case, and `force=`, as `instructions` does. A fresh process repeats the case on one thread while `sample` counts how often each function is at the top of the main thread's stack. A function's share of those samples, times the build's count from `instructions`, estimates its instructions per step. The estimate assumes every function retires instructions at the same rate. When a count moves, `profile_diff(case, base)` shows which functions moved it, from those estimates for both builds. A function that one build inlines and the other calls out of line appears under one build alone. Run them before reading machine code. `base` is a saved copy, and `bpl=PATH` sets the build to profile, the installed one by default.
 
 `bpl-tests NAME ARGUMENT...` runs one of these functions from the shell and prints its result: `check_file`, `check_page`, `time_cases`, `instructions`, `instruction_budgets`, `profile`, `profile_diff`, `speed_costs`, `thread_scaling`, `cargo_costs`, `pytest_costs`, `compare_costs` or `wasm_test`. Run long checks and timings this way, not in the shared kernel, which runs one cell at a time for every agent. For example, `bpl-tests time_cases '+/v' --threads 4` times `+/v` on four threads. `time_cases`, `instructions` and `speed_costs` take cases as positional arguments. When a case starts with `-`, put the cases last, after `--`, as in `bpl-tests speed_costs -- '-.×m' '+/v'`. `bpl-tests NAME -h` lists a function's arguments.
 
-On each push, the `Test` workflow logs every native cost in its `test` job and every wasm cost in its `wasm` job. The speed test that writes them times the test-profile build that the budgets limit. `bpl --costs FILE` times the cases in a file in `speed.txt`'s format as the speed test does, and prints each cost with this machine's budget, without failing on a budget. The manual `Speed` workflow runs it on a `dist` build, the profile releases use, on CI's runner, beside its wasm timing. The `Release` workflow runs it on each binary it builds, on GitHub's runners. Their logs show what releases cost, for comparison with the `Test` workflow's. `logged_costs` reads all three workflows' logs. When you review a run, look for costs over their budgets and for costs that changed by more than 20% since the run before. `compare_costs(before, after)` lists both, from two runs' logs or from the rows that `speed_costs` and the other timing functions give. A review needs each job's full log, because `ghapi`'s `failed_step_log` leaves out the step that prints the CPU model. Study a slowdown until you know its cause only when it appears in more than one CI run, or when two or more similar cases slow by similar amounts. Treat any other slowdown as normal variation.
+On each push, the `Test` workflow logs every native cost in its `test` job and every wasm cost in its `wasm` job. The speed test that writes them times the test-profile build that the budgets limit. `bpl --costs FILE` times the cases in a file in `speed.txt`'s format as the speed test does, and prints each cost with this machine's budget, without failing on a budget. The manual `Speed` workflow runs it on a `dist` build, the profile releases use, on CI's runner, beside its wasm timing. The `Release` workflow runs it on each binary it builds, on GitHub's runners. Their logs show what releases cost, for comparison with the `Test` workflow's. `logged_costs` reads all three workflows' logs. When you review a run, look for costs over their budgets and for costs that changed by more than 20% since the run before. `compare_costs(before, after)` lists both, from two runs' logs or from the rows that `speed_costs` and the other timing functions give. It measures each change on times per item where both runs give them, so a change to `COPIES` doesn't show as one. Every log names its CPU in its copy lines. Study a slowdown until you know its cause only when it appears in more than one CI run, or when two or more similar cases slow by similar amounts. Treat any other slowdown as normal variation.
 
-An initial budget is twice what a first-principles analysis says the case should cost, as each budget file's header says. A later budget comes from a fuller understanding of the case than that analysis gives, such as a platform difference or a cost the analysis missed, and the case's comment records it. A case over its budget needs study, which finds either a speed bug to fix or something the analysis missed. Avoid raising a budget to match a run without understanding why the case costs what it does. Each case line in a budget file holds a native budget for macOS on Apple silicon, then one for Linux on CI's x86 runner, then, in basedpl's file, a wasm budget. One expected cost serves every platform at first, until a specific difference on one platform is found. macOS running matrix products and decompositions on Accelerate, where CI runs rustymath's own kernels, is such a difference. A comment above each case, or above its group, gives the expected cost with its reason, and any platform's own cost with the reason for it. `set_budgets(expected)` writes the budgets for the cases that `expected` names, a dict from each case's code to its expected cost. `builds=` limits the change to one platform's column, for a cost that differs there. A case can appear in more than one section, such as `[copies]` and `[widths]`. `sections=` limits the change to the sections it names. `path=` selects one of rustymath's budget files, `tests/speed.txt` or `tests/speed_python.txt`.
+An initial budget is twice what a first-principles analysis says the case should cost, as each budget file's header says. A later budget comes from a fuller understanding of the case than that analysis gives, such as a platform difference or a cost the analysis missed, and the case's comment records it. A case over its budget needs study, which finds either a speed bug to fix or something the analysis missed. Avoid raising a budget to match a run without understanding why the case costs what it does. Each case line in a budget file holds a native budget for macOS on Apple silicon, then one for Linux on CI's x86 runner, then, in basedpl's file, a wasm budget for Node on CI's x86 runner. One expected cost serves every platform at first, until a specific difference on one platform is found. macOS running matrix products and decompositions on Accelerate, where CI runs rustymath's own kernels, is such a difference. A comment above each case, or above its group, gives the expected cost with its reason, and any platform's own cost with the reason for it. `set_budgets(expected)` writes the budgets for the cases that `expected` names, a dict from each case's code to its expected cost. `builds=` limits the change to one platform's column, for a cost that differs there. A case can appear in more than one section, such as `[copies]` and `[widths]`. `sections=` limits the change to the sections it names. `path=` selects one of rustymath's budget files, `tests/speed.txt` or `tests/speed_python.txt`.
 
 `tests/explain.rs`'s `speed_cases_take_their_routes` runs each speed case once more, after a warm-up run, as `•explain` runs its text (`timing::routes`). It fails on any slow-path event that the case's lines don't name: a pending array that a fused group computed on its own (`stored`), a call that computed pending items (`forced`), a batched map's fallback (`fallbacks`), a write that left an array mixed (`mixed`), or a route that handled items one at a time (`itemwise`). A line above a case names one event, as `•explain`'s record names it: the function for `forced`, the reason for `stored` and `fallbacks`, the code for `mixed` and the route for `itemwise`. A faster route that code considered and didn't take is a decline (`declined`), named by its route and reason, as in `fusion: an exact argument`. A case needn't name a decline, because each one explains another event, but a `gap` line can name one to record why the fast route was refused. Code in either repository reports a decline through `rustymath::events::declined`, which costs one atomic load unless `•explain` runs. `# allows RECORD "EVENT": principle` names an event that a principle allows, such as a matrix product reading its arguments whole. `# gap RECORD "EVENT": what should happen` names an event that a faster route should remove, and the test prints these gaps, which `cargo test -- --nocapture` shows. Any other event is a route to study, as a case over its budget is: add an `allows` line only for a principle, and a `gap` line once the study finds what should happen. The test also fails on a line whose event no longer appears, so a fixed gap's line goes.
 
@@ -48,7 +48,7 @@ For a change meant to make something faster, or a change to code that every call
 
 Cooperating tools share the machine's timing lock, `/tmp/aai-ws-timing.lock`. Timings take it exclusively. `cargo develop`, `cargo wait`, `cargo wasm`, the reference test, pytest, `check_file`, `check_page`, `bpl-nb` and `wasm_test` without `speed` take it shared. Rust code takes it through `rustymath::timing`. Python code takes it with `fastws.cargo.timing_lock`. Node can't lock a file. `wasm_test` and `speed_costs(wasm=DIR)` hold the lock in Python while Node runs. Other Rust tests and bare Cargo commands do not all take it. After five minutes a timing fails. A build or test run then goes ahead without the lock. After 30 seconds, an exclusive wait prints the processes with the lock file open. The list can include processes that are only waiting for the lock. Never take the lock yourself in the shared kernel process. Never coordinate timings by hand. A hold that outlasts its call blocks the timings that later calls launch. Each such call stalls every other agent's kernel calls while it waits. Native timings run on one thread and request user-interactive macOS QoS, which favours the performance cores. QoS is not CPU affinity.
 
-Run `cargo wasm` during development only for browser work. Agents use `cargo wasm --out DIR`, then run the browser tests against that build with `basedpl.bpltests.wasm_test(DIR)` for `tests/wasm.mjs` and `wasm_test(DIR, speed=True)` for `tests/wasm-speed.mjs`. This avoids replacing a module another agent is using. For other edits under `cfg(web)` or `host_web.rs`, check compilation with `cargo cs -p basedpl-wasm --target wasm32-unknown-unknown`, which checks the browser wrapper crate together with basedpl's browser code. `cargo cs` alone compiles neither.
+Run `cargo wasm` during development only for browser work. Agents use `cargo wasm --out DIR`, then run the browser tests against that build with `basedpl.bpltests.wasm_test(DIR)` for `tests/wasm.mjs` and `wasm_test(DIR, speed=True)` for `tests/wasm-speed.mjs`. That speed test fails on a wasm budget only on Linux x86-64, CI's platform. On any other host it prints every cost and marks each case still over its budget after the retries, as `bpl --costs` does. This avoids replacing a module another agent is using. For other edits under `cfg(web)` or `host_web.rs`, check compilation with `cargo cs -p basedpl-wasm --target wasm32-unknown-unknown`, which checks the browser wrapper crate together with basedpl's browser code. `cargo cs` alone compiles neither.
 
 ### X86-64 machine code
 
@@ -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, and beside NaN give the right argument, as a float. Their folds, scans and products start at the identity and put each item on the left, so a NaN item changes no running result. 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.69 → basedpl-0.1.71}/PKG-INFO

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

{basedpl-0.1.69 → basedpl-0.1.71}/nbs/glyphs/downstile.qmd

@@ -15,11 +15,12 @@ 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. Beside NaN, `X⌊Y` gives NaN or the other argument. `⌊/` and `⌊\` give NaN or the least other item. Which one depends on the processor and the code path. Remove NaNs first where that matters, 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 `Y`: `$n⌊3` is `3`, and `3⌊$n` is `$n`. A reduction or scan starts at `∞` and puts each item on the left, so it leaves NaN items out: `⌊/$n 1` is `1`, and `⌊/$n $n` is `∞`. A NaN seed stays NaN. Empty reduction identity: `∞`.
 
 ```bpl
 3⌊1 5             ⍝ 1 3
 3⌊1 $n 5          ⍝ 1 $n 3
+⌊\1 $n 3          ⍝ 1 1 1
 "abc"⌊"bab"       ⍝ "aab"
 3⌊'a'             ⍝ 3
 ```

{basedpl-0.1.69 → basedpl-0.1.71}/nbs/glyphs/upstile.qmd

@@ -9,11 +9,12 @@ 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. Beside NaN, `X⌈Y` gives NaN or the other argument. `⌈/` and `⌈\` give NaN or the greatest other item. Which one depends on the processor and the code path. Remove NaNs first where that matters, 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 `Y`: `$n⌈3` is `3`, and `3⌈$n` is `$n`. A reduction or scan starts at `¯∞` and puts each item on the left, so it leaves NaN items out: `⌈/$n 1` is `1`, and `⌈/$n $n` is `¯∞`. A NaN seed stays NaN. Empty reduction identity: `¯∞`.
 
 ```bpl
 3⌈1 5             ⍝ 3 5
 3⌈1 $n 5          ⍝ 3 $n 5
+⌈\1 $n 3          ⍝ 1 1 3
 "abc"⌈"bab"       ⍝ "bbc"
 3⌈'a'             ⍝ 'a'
 ```

{basedpl-0.1.69 → basedpl-0.1.71}/nbs/llms.txt

@@ -14,7 +14,7 @@ Each entry below names a difference from Dyalog APL, gives a short example, and
 
 ## Language
 
-- [Syntax](syntax.html.md): spaces divide a statement into runs, each read as one parenthesised group: `a+b × c+d` is `(a+b)(×)(c+d)`. Digits in a name need `_`, as in `x_1`. `x1` is `x` applied to `1`.
+- [Syntax](syntax.html.md): spaces divide a statement into runs, each read as one parenthesised group: `a+b × c+d` is `(a+b)(×)(c+d)`. A short run beside spaced runs is a group of its own: `1+k (⌈/⊢)⌸ a` is `(1+k)((⌈/⊢)⌸)(a)`. To keep code together, remove its spaces, as in `1+k(⌈/⊢)⌸a`, rather than wrapping it in parentheses. For items of a list, put them in brackets with `;` between them: `[+/x ; +/x ÷ ≢x]`. Digits in a name need `_`, as in `x_1`. `x1` is `x` applied to `1`.
 - [Evaluation](evaluation.html.md): a run that ends in a function is a train. `+/÷≢ x` is the mean of `x`, while `+/÷≢x` reads as `+/÷(≢x)`.
 - [Agreement](evaluation.html.md#agreement-and-pervasion): pervasive functions, Each and Rank align leading axes: `[1 2 3⋄4 5 6]+10 20` is `[11 12 13⋄24 25 26]`. An axis of length 1 expands.
 - [Maps](evaluation.html.md#functions-and-effects): Each, Rank, stencils and outer products call a dfn once on all their cells where they can: `{⍵×⍵+1}¨v` costs about what `v×v+1` costs. A predicate on a cell's value runs each body once, on the cells that take it. Output or a nested result makes them call the dfn once for each cell. A fold or scan by a dfn along each row of a matrix calls it once for each column, on every row at once. `f.g` calls a dfn `g` once, on all its pairings.

{basedpl-0.1.69 → basedpl-0.1.71}/python/basedpl/bpltests.py

@@ -314,14 +314,23 @@ def _program(code, n, setup):
 # The instructions that a case retires before the lowest value of `N` that `instructions` picks, and between successive values. A case that allocates an array at each step retires a few tens of millions more instructions over its first steps, while the allocator settles. `{↑[⍵ 1]}⍣N⊢0` counts the same from 3×10⁴ steps on, about 2×10⁸ instructions, and `{fib 10}⍣N⊢0` from 30 steps on. Each process pays a different warm-up, up to about 5×10⁶ instructions, which moves a slope over 5×10⁸ instructions by under 1%. Some cases also pay a one-off cost once `N` passes a size: `≢•ucs N⍴"ab" "cde"` retires about 5×10⁶ more instructions from about 131,350 items on.
 _SETTLE, _SPAN = 5e8, 5e8
 
+# A case that names `N` outside its strings says itself how it repeats. `_stepped` runs any other case once per step.
+_NAMES_N, _QUOTED = re.compile(r'(?<!\w)N(?!\w)'), re.compile(r'"(?:[^"]|"")*"|\'.\'')
+
+def _stepped(case, force=False):
+    "BPL that makes one call of `case` per step of `N`. A case that names `N`, such as `{⍵}⍣N⊢0`, is that BPL already. Any other case runs once per step, and its result is dropped, or with `force` computed in full through an indexed write. `force` needs a result of rank 1 or more."
+    if _NAMES_N.search(_QUOTED.sub('', case)): return case
+    return f'{{x←{case} ⋄ x.[0]←x.[0] ⋄ ⍵}}⍣N⊢0' if force else f'{{{case} ⋄ ⍵}}⍣N⊢0'
+
 def instructions(
-    cases:Annotated[str, {'nargs':'+'}], # A BPL expression that makes one call per step of `N`, such as `{⍵}⍣N⊢0`, or a list of them
+    cases:Annotated[str, {'nargs':'+'}], # A BPL expression to run once per step, such as `k(⌈/⊢)⌸a`, or one that names `N` and makes its own call per step of it, such as `{⍵}⍣N⊢0`, or a list of them
     setup='', # BPL that defines what the cases use, run before each case
+    force=False, # Compute each step's result in full where it would stay pending, such as large windows or a transpose, for the cases that don't name `N`
     counts:Annotated[int, {'nargs':'+'}]=None, # Two or more values of `N`; None: four values past the allocator's warm-up, from a rough count at 1,000 steps
     runs=3, # Processes at each value of `N`, of which the lowest count is used
     bpl:Path=None # A native `bpl` to count, such as a copy saved before a change; None: the installed one
 ):
-    "The instructions that each case retires per unit of `N`, on one thread. For each pair of successive values of `N`, the difference between fresh `bpl` processes, divided by the difference in `N`, cancels startup and `setup`. The result is the median of those slopes. The median drops a one-off cost that starts once `N` passes some size, because such a cost falls between only one pair. Unlike timings, instruction counts don't vary with load or code layout, so they show per-call changes of a few percent. A case must make one call per step of `N`, as `⍣` does: a map such as `f¨N⍴0` calls a dfn once on all its cells, so it gives no per-call cost."
+    "The instructions that each case retires per unit of `N`, on one thread. A case that doesn't name `N` runs once per step inside `{case ⋄ ⍵}⍣N⊢0`. That dfn's own call adds about 1,900 instructions per step. For each pair of successive values of `N`, the difference between fresh `bpl` processes, divided by the difference in `N`, cancels startup and `setup`. The result is the median of those slopes. The median drops a one-off cost that starts once `N` passes some size, because such a cost falls between only one pair. Unlike timings, instruction counts don't vary with load or code layout, so they show per-call changes of a few percent. A case that names `N` must make one call per step of `N`, as `⍣` does: a map such as `f¨N⍴0` calls a dfn once on all its cells, so it gives no per-call cost."
     cases = [cases] if isinstance(cases, str) else list(cases)
     def count(code, n, runs=runs): return min(_retired(_program(code, n, setup), bpl) for _ in range(runs))
     def steps(code):
@@ -331,8 +340,8 @@ def instructions(
     def per_step(code):
         ns = steps(code)
         cs = [count(code, n) for n in ns]
-        return code, statistics.median((c1-c0)/(n1-n0) for n0, n1, c0, c1 in zip(ns, ns[1:], cs, cs[1:]))
-    return Instructions(per_step(code) for code in cases)
+        return statistics.median((c1-c0)/(n1-n0) for n0, n1, c0, c1 in zip(ns, ns[1:], cs, cs[1:]))
+    return Instructions((case, per_step(_stepped(case, force))) for case in cases)
 
 class ProfileDiff(list):
     "Each function's estimated instructions per step of `N` on two builds, as `(function, before, after)` rows, largest change first, below a row of each build's total."
@@ -372,11 +381,12 @@ def _self_samples(code, bpl, seconds):
     for name, n in zip(subprocess.run(['c++filt'], input='\n'.join(selfs), capture_output=True, text=True).stdout.splitlines(), selfs.values()): named[name] += n
     return named, total
 
-def _estimates(case, setup, bpl, seconds):
+def _estimates(case, setup, bpl, seconds, force):
     "Each function's estimated instructions per step of `N` for `case` on `bpl`, and the build's instructions per step, as `profile` describes."
     if sys.platform != 'darwin': raise ValueError(f'no sampling profiler on {sys.platform}')
-    [(_, per_step)] = instructions(case, setup, bpl=bpl)
-    samples, total = _self_samples(_program(f'{{⍵⊣({case})}}⍣1000000000⊢0', max(1, round(1e8/per_step)), setup), bpl, seconds)
+    stepped = _stepped(case, force)
+    [(_, per_step)] = instructions(stepped, setup, bpl=bpl)
+    samples, total = _self_samples(_program(f'{{{stepped} ⋄ ⍵}}⍣1000000000⊢0', max(1, round(1e8/per_step)), setup), bpl, seconds)
     return {f: per_step*n/total for f, n in samples.items()}, per_step
 
 class Profile(list):
@@ -387,26 +397,28 @@ class Profile(list):
     def __repr__(self): return '\n'.join(f'{n:>10,.0f} {n/self.total:>6.1%}  {f[:150]}' for f, n in [('total', self.total), *self])
 
 def profile(
-    case, # A BPL expression that makes one call per step of `N`, as `instructions` takes, such as `{⍵}⍣N⊢0`
+    case, # A BPL expression, as `instructions` takes it, such as `k(⌈/⊢)⌸a` or `{⍵}⍣N⊢0`
     setup='', # BPL that defines what the case uses, run before it
+    force=False, # Compute each step's result in full, as `instructions`' `force` does
     bpl:Path=None, # A native `bpl` to profile, such as a copy saved before a change; None: the installed one
     seconds=3, # How long macOS `sample` watches the build
     rows=20 # How many functions to show
 ):
     "Where `case`'s instructions per step of `N` go, by function, on macOS. A fresh process repeats the case on one thread while `sample` counts how often each function is at the top of the main thread's stack. A function's estimate is its share of those samples times the build's instructions per step from `instructions`. The shares come from time, so the estimates assume every function retires instructions at the same rate."
-    estimates, total = _estimates(case, setup, bpl, seconds)
+    estimates, total = _estimates(case, setup, bpl, seconds, force)
     return Profile(sorted(estimates.items(), key=lambda r: -r[1])[:rows], total)
 
 def profile_diff(
-    case, # A BPL expression that makes one call per step of `N`, as `instructions` takes, such as `{⍵}⍣N⊢0`
+    case, # A BPL expression, as `instructions` takes it, such as `k(⌈/⊢)⌸a` or `{⍵}⍣N⊢0`
     base:Path, # A native `bpl` to compare with, such as a copy saved before a change
     setup='', # BPL that defines what the case uses, run before it
+    force=False, # Compute each step's result in full, as `instructions`' `force` does
     bpl:Path=None, # A native `bpl` to compare with `base`; None: the installed one
     seconds=3, # How long macOS `sample` watches each build
     rows=20 # How many functions to show
 ):
     "Where `case`'s instructions per step of `N` moved between two builds, by function, on macOS, from `profile`'s estimates for each build. A function that only one build calls out of line, such as one that stopped being inlined, appears in that build alone."
-    (before, tb), (after, ta) = _estimates(case, setup, base, seconds), _estimates(case, setup, bpl, seconds)
+    (before, tb), (after, ta) = _estimates(case, setup, base, seconds, force), _estimates(case, setup, bpl, seconds, force)
     fs = sorted(before.keys() | after.keys(), key=lambda f: -abs(after.get(f, 0) - before.get(f, 0)))
     return ProfileDiff([(f, before.get(f, 0), after.get(f, 0)) for f in fs[:rows]], (tb, ta))
 
@@ -449,11 +461,11 @@ def _or_dash(x, spec): return '-' if x is None else format(x, spec)
 def _over(cost, budget): return budget is not None and cost > budget
 
 class SpeedCosts(list):
-    "Each case's cost and the budget that limits it, as `(section, code, cost, budget)` rows. A cost is in copies, except in `[widths]`, where it is the 32-bit time as a fraction of the 64-bit time. A case with no budget has `None`. A case over its budget needs study, which finds either a speed bug or something its expected cost missed. `cpu` is the CPU model that a CI log reports, or `None`. `platform` is the platform whose native budgets the costs were checked against, 'macos' or 'linux', or `None` for a browser build. `copies` holds the copy lines that a log gives, as `(items, bytes, ns per item, stored)` rows, which say whether `rustymath::timing::COPIES` held that machine's copy time or the test measured it."
+    "Each case's cost and the budget that limits it, as `(section, code, cost, budget, ns)` rows. A cost is in copies, except in `[widths]`, where it is the 32-bit time as a fraction of the 64-bit time. A case with no budget has `None`. `ns` is the case's time for each item in nanoseconds, or `None` where the timing doesn't give it. Times compare across a change to `rustymath::timing::COPIES`, where costs don't. A case over its budget needs study, which finds either a speed bug or something its expected cost missed. `cpu` is the CPU model that a CI log reports, or `None`. `platform` is the platform whose native budgets the costs were checked against, 'macos' or 'linux', or `None` for a browser build. `copies` holds the copy lines that a log gives, as `(items, bytes, ns per item, stored)` rows, which say whether `rustymath::timing::COPIES` held that machine's copy time or the test measured it."
     def __init__(self, rows=(), cpu=None, platform=None, copies=()):
         super().__init__(rows)
         self.cpu, self.platform, self.copies = cpu, platform, list(copies)
-    def __repr__(self): return '\n'.join(f'{cost:>9.2f} {_or_dash(b, "g"):>9} {"over" if _over(cost, b) else "":4}  {s} {c}' for s, c, cost, b in self)
+    def __repr__(self): return '\n'.join(f'{cost:>9.2f} {_or_dash(b, "g"):>9} {_or_dash(ns, ".3f"):>9} {"over" if _over(cost, b) else "":4}  {s} {c}' for s, c, cost, b, ns in self)
 
 def speed_costs(
     wasm:Path=None, # A directory that `cargo wasm --out` wrote, to time in that browser build, as `tests/wasm-speed.mjs` does; None: a fresh native worker, as `tests/speed.rs` does
@@ -481,44 +493,47 @@ def speed_costs(
         rows = json.loads(p.stdout)
     build = _platform() if wasm is None else 'wasm'
     i = _BUDGETS.index(build)
-    rows = ((c['section'], c['code'], c['cost'], float(c['budgets'][i]) if len(c['budgets']) > i else None) for c in rows)
+    rows = ((c['section'], c['code'], c['cost'], float(c['budgets'][i]) if len(c['budgets']) > i else None, c['seconds']*1e9 if 'seconds' in c else None) for c in rows) # A saved `bpl` from before 23 October 2026 gives no `seconds`
     return SpeedCosts(rows, platform=None if wasm else build)
 
-_LOGGED = re.compile(r'^(?:\S*Z )?(?P<tap># )?(?P<section>\w+) (?P<code>\S.*): (?P<cost>[\d.]+|inf|NaN|Infinity), budget (?P<budget>[\d.]+)(?:, [\d.]+ ns)?$')
-_CPU = re.compile(r'^(?:\S*Z )?model name\s*:\s*(.+?)\s*$', re.M)
-_COPY = re.compile(r'^(?:\S*Z )?(?:# )?copy of (?P<items>\d+) (?P<bytes>\d+)-byte items: (?P<ns>[\d.]+) ns an item, (?P<source>stored|measured)', re.M)
+_LOGGED = re.compile(r'^(?:\S*Z )?(?P<tap># )?(?P<section>\w+) (?P<code>\S.*): (?P<cost>[\d.]+|inf|NaN|Infinity), budget (?P<budget>[\d.]+)(?:, (?P<ns>[\d.]+) ns)?$')
+_COPY = re.compile(r'^(?:\S*Z )?(?:# )?copy of (?P<items>\d+) (?P<bytes>\d+)-byte items: (?P<ns>[\d.]+) ns an item, (?P<source>stored for|measured on) (?P<cpu>[^\r\n]+?)(?:: add it to rustymath::timing::COPIES)?[ \t]*$', re.M)
 
 def logged_costs(
     log, # What a speed test prints with `<NAME>_COSTS` set, such as the log of a job in the `Test` or `Speed` workflow, or the path of a file that holds it
     platform='linux' # The platform whose native budgets the log's costs were checked against: 'linux' for CI's runner, or 'macos' for a Mac
 ):
-    "The rows that `speed_costs` gives, read from `log`, with the CPU model that the log reports as their `cpu`, `platform`, and the log's copy lines as `copies`. A case that the log times more than once, as after a retry, gives its lowest cost."
+    "The rows that `speed_costs` gives, read from `log`, with the CPU that its copy lines name as their `cpu`, `platform`, and the log's copy lines as `copies`. A case that the log times more than once, as after a retry, gives its lowest cost, with that timing's time for each item where the log prints one."
     if isinstance(log, Path): log = log.read_text()
-    cpu = c[1] if (c := _CPU.search(log)) else None
+    found = list(_COPY.finditer(log))
+    cpu = next((m['cpu'] for m in found if m['cpu'] != 'a CPU with no name'), None)
     rows = {}
     for m in filter(None, map(_LOGGED.match, log.splitlines())):
         code = re.sub(r'\\([\\#])', r'\1', m['code']) if m['tap'] else m['code'] # Node's TAP diagnostics escape `\` and `#`
-        row = (m['section'], code, float(m['cost']), float(m['budget']))
+        row = (m['section'], code, float(m['cost']), float(m['budget']), m['ns'] and float(m['ns']))
         if row[:2] not in rows or row[2] < rows[row[:2]][2]: rows[row[:2]] = row
-    copies = list(dict.fromkeys((int(m['items']), int(m['bytes']), float(m['ns']), m['source'] == 'stored') for m in _COPY.finditer(log)))
+    copies = list(dict.fromkeys((int(m['items']), int(m['bytes']), float(m['ns']), m['source'] == 'stored for') for m in found))
     return SpeedCosts(rows.values(), cpu, platform, copies)
 
 CHANGE = 0.2
 class CostChanges(list):
-    "The cases that `compare_costs` reports, as `(section, code, before, after, budget)` rows. Cases over their budget in `after` come first, then cases whose cost moved by more than `CHANGE`, largest change first. `before` is `None` for a case that the earlier run didn't time, and `budget` is `None` for a case with no budget."
-    def __repr__(self): return '\n'.join(f'{_or_dash(b, ".2f"):>9} {a:>9.2f} {_or_dash(b and a/b-1, "+.0%"):>6} {_or_dash(budget, "g"):>9} {"over" if _over(a, budget) else "":4}  {s} {c}' for s, c, b, a, budget in self)
+    "The cases that `compare_costs` reports, as `(section, code, before, after, budget, change)` rows. `before` and `after` are costs. `change` is the fractional change in the case's time for each item where both runs give one, and in its cost otherwise, so it holds across a change to `rustymath::timing::COPIES`. Cases over their budget in `after` come first, then cases whose change is more than `CHANGE`, largest first. `before` and `change` are `None` for a case that the earlier run didn't time, and `budget` is `None` for a case with no budget."
+    def __repr__(self): return '\n'.join(f'{_or_dash(b, ".2f"):>9} {a:>9.2f} {_or_dash(d, "+.0%"):>6} {_or_dash(budget, "g"):>9} {"over" if _over(a, budget) else "":4}  {s} {c}' for s, c, b, a, budget, d in self)
 
 def compare_costs(
     before:Annotated[SpeedCosts|str|Path, {'type':Path}], # The earlier run: rows that `speed_costs`, `logged_costs`, `cargo_costs` or `pytest_costs` give, or a log that `logged_costs` reads, as its text or its path
     after:Annotated[SpeedCosts|str|Path, {'type':Path}], # The later run, in any of `before`'s forms
     platform='linux' # The platform whose native budgets a log's costs were checked against, as `logged_costs` takes it
 ):
-    "Each case over its budget in `after`, and each case whose cost moved by more than `CHANGE` from `before` in either direction."
+    "Each case over its budget in `after`, and each case whose time for each item moved by more than `CHANGE` from `before` in either direction, or whose cost did where either run doesn't give the time."
     before, after = (x if isinstance(x, SpeedCosts) else logged_costs(x, platform) for x in (before, after))
-    old = {(s, c): cost for s, c, cost, _ in before}
-    rows = [(s, c, old.get((s, c)), cost, budget) for s, c, cost, budget in after]
-    def change(row): return abs(row[3]/row[2] - 1) if row[2] else 0
-    return CostChanges(sorted((r for r in rows if _over(r[3], r[4]) or change(r) > CHANGE), key=lambda r: (not _over(r[3], r[4]), -change(r))))
+    old = {(s, c): (cost, ns) for s, c, cost, _, ns in before}
+    rows = []
+    for s, c, cost, budget, ns in after:
+        cost0, ns0 = old.get((s, c), (None, None))
+        rows.append((s, c, cost0, cost, budget, ns/ns0 - 1 if ns and ns0 else cost/cost0 - 1 if cost0 else None))
+    def moved(row): return abs(row[5] or 0)
+    return CostChanges(sorted((r for r in rows if _over(r[3], r[4]) or moved(r) > CHANGE), key=lambda r: (not _over(r[3], r[4]), -moved(r))))
 
 def _run_costs(cmd, path, timeout, native=False, env=None):
     "The rows that `logged_costs` reads from what `cmd` prints, run in the package at `path` with `<NAME>_COSTS` set. A case over its budget still gives its row."

{basedpl-0.1.69 → basedpl-0.1.71}/python/basedpl/notebook_runner.py

@@ -5,7 +5,6 @@ from pathlib import Path
 from fastcore.script import call_parse
 from fastcore.xtras import working_directory
 from fastcore.nbio import write_nb
-from fastws.cargo import timing_lock
 from . import bpl
 
 LANGUAGES = {'bpl', 'hpl'}
@@ -34,6 +33,8 @@ def main(
     save:bool=False, # Save outputs in the notebook
 ):
     "Run BPL notebooks without starting Jupyter, holding the timing lock shared."
+    try: from fastws.cargo import timing_lock
+    except ImportError: raise SystemExit("bpl-nb runs basedpl's own notebooks and needs the dev extras: pip install 'basedpl[dev]'")
     with timing_lock():
         paths = sorted(path.rglob('*.ipynb')) if path.is_dir() else [path]
         for p in paths:

{basedpl-0.1.69 → basedpl-0.1.71}/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.69 → basedpl-0.1.71}/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.69 → basedpl-0.1.71}/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());

{basedpl-0.1.69 → basedpl-0.1.71}/src/timing.rs

@@ -1,6 +1,7 @@
 //! The speed test's measurements, shared by `tests/speed.rs`, the browser build's `costs` and the worker's `timing` and `costs` requests, which serve `basedpl.bpltests.time_cases` and `speed_costs`. A time is the fastest of five evaluations of a case, after one to warm up. The case is parsed once, before them. Its unit is one copy of the `n` items in the data of the `[setup]` before the case's section, as `rustymath::timing::copy_time` gives it: this machine's stored copy time, or one measured once. `costs` and `request` hold the machine's timing lock exclusively while they run, as `rustymath::timing` describes.
 use crate::{host::timing_lock, protocol::response, EvalOptions, Evaluation, InterruptHandle, Session, Source, Turn};
-use rustymath::timing::{code_of, copy_time, header, sections, CopyTime};
+use rustymath::timing::{code_of, copy_time, header, sections, CopyTime, NATIVE_COLUMN};
+pub use rustymath::timing::name_cpu;
 use serde_json::{json, Value as JsonValue};
 use rustymath::hashing::{HashMap, HashMapExt};
 
@@ -69,15 +70,23 @@ pub fn time(session: &Session, code: &str, interrupt: &InterruptHandle) -> Resul
     failed.map_or(Ok(seconds), Err)
 }
 
+/// The column of a case's wasm budget in basedpl's `tests/speed.txt`, after the macOS and Linux budgets that `rustymath::timing::NATIVE_COLUMN` picks from.
+pub const WASM_COLUMN: usize = 2;
+
 /// One case of a file in `speed.txt`'s format, with its cost: the section it's in, its code, its budgets in the file's order, the cost those budgets limit, its time for each of the section's `n` items in seconds, and the copy that its cost counts, which `[widths]` costs don't use.
 pub struct Case<'a> { pub section: &'a str, pub code: &'a str, pub budgets: Vec<&'a str>, pub cost: f64, pub seconds: f64, pub copy: Option<CopyTime> }
 impl Case<'_> {
-    /// This case's line in a speed test's log, with the budget in `column` of its budgets: 0 for macOS, 1 for Linux, 2 for the browser build. `basedpl.bpltests.logged_costs` reads these lines.
+    /// This case's line in a speed test's log, with the budget in `column` of its budgets: `rustymath::timing::NATIVE_COLUMN` for this platform's native budget, or `WASM_COLUMN`. `basedpl.bpltests.logged_costs` reads these lines.
     pub fn line(&self, column: usize) -> String { rustymath::timing::line(self.section, self.code, self.cost, self.budgets.get(column).copied().unwrap_or("-"), self.seconds) }
     /// The copy line of the copy that this case's cost counts, as `rustymath::timing::copy_line` writes it. `None` in `[widths]`.
     pub fn copy_line(&self) -> Option<String> { self.copy.as_ref().map(rustymath::timing::copy_line) }
 }
 
+/// Each of `cases` as JSON, as the worker's `costs` reply and the browser build's `costs` give it: its section, code, log `line` with the budget in `column` of its budgets, `copy` line or null, budgets, cost, and time for each item in `seconds`.
+pub fn rows(cases: &[Case], column: usize) -> JsonValue {
+    cases.iter().map(|c| json!({"section": c.section, "code": c.code, "line": c.line(column), "copy": c.copy_line(), "budgets": c.budgets, "cost": c.cost, "seconds": c.seconds})).collect()
+}
+
 /// One group of sections, which share the group's `[setup]` and one session, set up for one section at a time: each section's `•prefs` header, the section the session is set up for, and the setup's `n`.
 struct Group<'a> { session: Turn, setup: String, prefs: HashMap<&'a str, &'a str>, current: &'a str, n: usize }
 
@@ -218,13 +227,11 @@ pub fn request(spec: &JsonValue, interrupt: &InterruptHandle) -> Result<JsonValu
     Ok(json!({"n": n, "costs": costs, "output": [], "error": null}))
 }
 
-/// The reply to the worker's `costs` request, which gives `speed`, text in `speed.txt`'s format, and optionally `cases`, a list of the codes to time. The reply gives each case with its cost, as `costs` times them: its section, code, budgets and cost.
+/// The reply to the worker's `costs` request, which gives `speed`, text in `speed.txt`'s format, and optionally `cases`, a list of the codes to time. The reply gives each case with its cost, as `costs` times them and `rows` encodes them, with this platform's native budget in each log line.
 pub fn file_request(spec: &JsonValue, interrupt: &InterruptHandle) -> Result<JsonValue, String> {
     let only: Option<Vec<&str>> = match spec.get("cases") {
         None | Some(JsonValue::Null) => None,
         Some(cases) => Some(cases.as_array().and_then(|c| c.iter().map(JsonValue::as_str).collect()).ok_or("costs needs cases as a list of strings")?),
     };
-    let cases = costs(spec["speed"].as_str().ok_or("costs needs speed as a string")?, only.as_deref(), interrupt)?;
-    let cases: Vec<_> = cases.iter().map(|c| json!({"section": c.section, "code": c.code, "budgets": c.budgets, "cost": c.cost})).collect();
-    Ok(json!({"costs": cases, "error": null}))
+    Ok(json!({"costs": rows(&costs(spec["speed"].as_str().ok_or("costs needs speed as a string")?, only.as_deref(), interrupt)?, NATIVE_COLUMN), "error": null}))
 }

{basedpl-0.1.69 → basedpl-0.1.71}/tests/reference/core.bpl

@@ -4759,10 +4759,14 @@ $t $t $t $t $t $t $t
 $t $t $t $t
 $t $t $t $t $t
 
-⍝ — Under dynamic kinds, ⌊ and ⌈ keep an exact number exact beside an infinity or NaN. On a large array they don't fuse beside an exact number or a comparison, because a fused graph reads them as floats
+⍝ — Under dynamic kinds, ⌊ and ⌈ keep an exact number exact beside an infinity, and give their right argument beside NaN, as a float. On a large array they don't fuse beside an exact number or a comparison, because a fused graph reads them as floats
 x←¿1000000⍴0 ⋄ x.[[0 1 2 3]]←[∞ ¯∞ $n 0] ⋄ [4↑x⌊0ₓ ⋄ 4↑x⌈0ₓ ⋄ 4↑x⌊x>0 ⋄ 4↑x⌈$t]
 [0ₓ ¯∞ 0 0⋄∞ 0ₓ 0 0⋄1ₓ ¯∞ 0 0⋄∞ 1ₓ 1 1]
 
+⍝ max-min-nan — ⌈ and ⌊ give their right argument beside NaN, and every fold, scan and product starts at ¯∞ or ∞ with each item on the left, so a NaN item changes no running result and a NaN seed stays: dyadic in either order, folds and scans short and long, columns, Key, seeded folds, windows, rows, products, exact and mixed numbers, and a long fold split into pieces
+nans←{+/,~⍵=⍵} ⋄ r←⌈\(⍳10),$n,⍳53 ⋄ m←64 64⍴0.5+⍳4096 ⋄ m.[3 5]←$n ⋄ q←1000 4⍴0.5+⍳4000 ⋄ q.[7 2]←$n ⋄ p←100 20⍴0.5+⍳2000 ⋄ p.[3 4]←$n ⋄ w←0.5+⍳200 ⋄ w.[100]←$n ⋄ s←0.5+⍳1000000 ⋄ s.[900000]←$n ⋄ s.[900001]←1e9 ⋄ [$n⌈3;3⌈$n;$n⌊3;3⌊$n;⌈/1 $n 3;⌊/1 $n 3;⌈/$n,⍳15;⌈/(⍳15),$n;⌈/$n $n;⌈\$n 1 2;⌊\1 $n 3;nans ⌈\$n,⍳63;10↑r;nans r;⌈⌿[1 $n⋄3 4];nans ⌈⌿m;0 1 0 1 (⌈/⊢)⌸ 1 $n 3 4;0⌈/$n 1 2;0⌈/$n,⍳20;⌈/3↕1 $n 3 4 5;nans ⌈/50↕w;⌈/⍤1 [1 $n 3⋄4 5 6];nans ⌈/⍤1 q;nans ⌈/⍤1 p;nans ⌈/⍤1 m;[1 $n⋄3 4]⌈.+2 2⍴0;nans m⌈.+m;nans m⌊.+m;1ₓ⌈$n;$n⌊1ₓ;⌈/1ₓ $n 2.5;⌈/s;⌊/s;$n⌈/⍳40;nans $n⌈\⍳300]
+[3 $n 3 $n 3 1 14 14 ¯∞ [¯∞ 1 2] [1 1 1] 0ₓ [0 1 2 3 4 5 6 7 8 9] 0ₓ [3 4] 0ₓ [3 4] 2 19 [3 4 5] 0ₓ [3 6] 0ₓ 0ₓ 0ₓ [1 1⋄4 4] 0ₓ 0ₓ $n 1 2.5 1000000000 0.5 $n 300ₓ]
+
 ⍝ — With •prefs ["fusion":$t], a call that computes a pending argument reports its glyph and position
 x←1.5+¿1000000⍴0 ⋄ •prefs ["fusion":$t] ⋄ r←⍴⍋x ⋄ •prefs ["fusion":$f] ⋄ r
 [1000000]ₓ