basedpl 0.1.71__tar.gz → 0.1.72__tar.gz

{basedpl-0.1.71 → 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.71 → basedpl-0.1.72}/Cargo.lock

@@ -93,7 +93,7 @@ checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 
 [[package]]
 name = "basedpl"
-version = "0.1.71"
+version = "0.1.72"
 dependencies = [
  "base64 0.23.1",
  "bytemuck",
@@ -137,7 +137,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-cli"
-version = "0.1.71"
+version = "0.1.72"
 dependencies = [
  "async-trait",
  "basedpl",
@@ -150,7 +150,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-py"
-version = "0.1.71"
+version = "0.1.72"
 dependencies = [
  "basedpl",
  "num-bigint",
@@ -165,7 +165,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-wasm"
-version = "0.1.71"
+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.45"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "539dbd536cc6c64e9080a2c0bc346b6cf2f5308f0e29f814bfefd244bce87d07"
+checksum = "f160fb701304e3888885ade3929ef93b7c7d1aaab5ae61f16c0ec0e01f270cab"
 dependencies = [
  "foldhash",
  "half",
@@ -1434,9 +1434,9 @@ dependencies = [
 
 [[package]]
 name = "rustymath-buffer"
-version = "0.1.45"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b3f549d927a69037ffe1ec3d11a318d89bbb115ac26c071d19150207e62a811"
+checksum = "1c1457056dae79ecf521f89d600f82a2a954e601ecd8d478e495b65cb6145010"
 dependencies = [
  "pyo3",
  "rustymath",
@@ -2086,7 +2086,7 @@ checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
 
 [[package]]
 name = "xtask"
-version = "0.1.71"
+version = "0.1.72"
 dependencies = [
  "anyhow",
  "rustymath",

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

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

{basedpl-0.1.71 → 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 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.
+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.71 → basedpl-0.1.72}/PKG-INFO

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

{basedpl-0.1.71 → 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. 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: `∞`.
+`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 1 1
 "abc"⌊"bab"       ⍝ "aab"
 3⌊'a'             ⍝ 3
 ```

{basedpl-0.1.71 → 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. 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: `¯∞`.
+`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 1 3
 "abc"⌈"bab"       ⍝ "bbc"
 3⌈'a'             ⍝ 'a'
 ```

{basedpl-0.1.71 → 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.71 → 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.71 → 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.71 → 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.71 → 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.71 → 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.71 → 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.71 → basedpl-0.1.72}/src/pervasive.rs

@@ -32,6 +32,8 @@ pub(crate) trait Dyad<A> {
     fn many(self, f: impl rustymath::Binary<A, Out = A> + Copy + Sync) -> Self::Output;
     /// `f`, which gives Booleans, on each pair of items, through its slice form where the loop has slices of items, and its scalar form elsewhere.
     fn booleans(self, f: impl rustymath::Binary<A, Out = bool> + Copy + Sync) -> Self::Output;
+    /// `f`, a maximum or minimum, as `many` runs it. A loop that folds values into a running result, as `Scatter` does at a place it writes more than once, folds them by `M` instead. `M`'s step keeps the running result beside a NaN value, where `f`'s keeps the value.
+    fn extremum<M: Reduction<A, Total = A>>(self, f: impl rustymath::Binary<A, Out = A> + Copy + Sync, _: M) -> Self::Output where Self: Sized { self.many(f) }
     /// `f`, a comparison, on each pair of items, as `booleans` runs it. A loop that writes floats in place of Booleans writes 1 where `f` holds and 0 elsewhere, through `rustymath::tolerant::Indicator`. The nodes of a fused graph before its last write a comparison this way.
     fn compared<K: rustymath::Binary<A, Out = bool> + Copy + Sync>(self, f: K) -> Self::Output where Self: Sized, rustymath::tolerant::Indicator<K>: rustymath::Binary<A, Out = A> { self.booleans(f) }
     /// The left and the right argument, each when it is one number that every item pairs with. A kernel can then run a loop of its own for that number, as `x*2` squares each item.
@@ -166,8 +168,8 @@ mod float_kernels {
                     },
                     Primitive::Math(Pi) => run.many(rustymath::PiTimes),
                     Primitive::Math(Log) => run.many(rustymath::Logb),
-                    Primitive::Math(Ceiling) => run.many(reduce::Maximum),
-                    Primitive::Math(Floor) => run.many(reduce::Minimum),
+                    Primitive::Math(Ceiling) => run.extremum(reduce::Maximum, reduce::Max),
+                    Primitive::Math(Floor) => run.extremum(reduce::Minimum, reduce::Min),
                     Primitive::Math(Magnitude) => run.many(rustymath::tolerant::Residue(t)),
                     Primitive::Math(Root) => match run.constants() {
                         (Some(n), _) if n == 2.0 => run.many(Right(rustymath::Sqrt)),
@@ -537,6 +539,9 @@ impl<A: Stored> Dyad<A> for Scatter<'_, A> {
         self.writes.combine(self.out, self.values, move |x, y| f.one(x, y));
         Some(Route::InPlace)
     }
+    fn extremum<M: Reduction<A, Total = A>>(self, _: impl rustymath::Binary<A, Out = A> + Copy + Sync, _: M) -> Option<Route> {
+        self.writes.fold::<M, A>(self.out, self.values).then_some(Route::InPlace)
+    }
     fn booleans(self, _: impl rustymath::Binary<A, Out = bool> + Copy + Sync) -> Option<Route> { None }
 }
 
@@ -1298,24 +1303,20 @@ impl<'a, A: Stored> Fold<'a, A> {
         let tail = match tail { None => None, Some(view) => Some(carried::<A>(view)?) };
         Some(Self { data, dims, tail, numeric })
     }
-    /// The fold by `f`, which gives `None` where a step fails.
+    /// The fold by `f` through rustymath's right fold. `None` where a step fails, unless `kept` keeps its failed results, as static kinds keep wrapped integers.
     #[inline]
-    fn by(self, f: impl Fn(A, A) -> Option<A> + Copy + Sync) -> Option<Buffer> {
-        Some(A::buffer(reduce::right_fold(self.data, self.dims, self.tail.as_deref(), f, |x| x)?))
+    fn by<O: Element + Source<A>>(self, f: &impl rustymath::Binary<A, Out = O>) -> Option<Buffer> {
+        let (out, ok) = reduce::right_fold(f, self.data, self.dims, self.tail.as_deref());
+        (ok || kept(f, self.numeric)).then(|| O::buffer(out))
     }
 }
 impl<A: Stored> Dyad<A> for Fold<'_, A> where bool: Source<A> {
     type Output = Option<Buffer>;
     fn numeric(&self) -> Numeric { self.numeric }
-    /// Each step through `f`'s scalar form. A step that fails gives `None`, unless `keeps` keeps `f`'s failed results, as static kinds keep wrapped integers. An object none of whose steps fails compiles only the first loop.
     #[inline]
-    fn many(self, f: impl rustymath::Binary<A, Out = A> + Copy + Sync) -> Self::Output {
-        if total(&f) || kept(&f, self.numeric) { self.by(move |x, y| Some(f.one(x, y))) } else { self.by(move |x, y| f.checked(x, y)) }
-    }
+    fn many(self, f: impl rustymath::Binary<A, Out = A> + Copy + Sync) -> Self::Output { self.by(&f) }
     #[inline]
-    fn booleans(self, f: impl rustymath::Binary<A, Out = bool> + Copy + Sync) -> Self::Output {
-        Some(bool::buffer(reduce::right_fold(self.data, self.dims, self.tail.as_deref(), move |x, y| f.checked(x, y), Source::<A>::read)?))
-    }
+    fn booleans(self, f: impl rustymath::Binary<A, Out = bool> + Copy + Sync) -> Self::Output { self.by(&f) }
 }
 
 /// A scan of compact values along `axis` by successive left accumulation, as the general scan does. Kernels of approximate numbers compare within the tolerance of their width in the current settings.
@@ -1389,9 +1390,17 @@ fn scanned_under(p: Primitive, right: &Value, seed: Option<&Value>, axis: &Lanes
     }
     match right.as_items() {
         // The logical functions and comparisons keep Booleans, and scan through their truth tables. Other functions read Booleans as integers.
-        Items::Compact(View::Booleans(data)) => match bool::dyad(p, LogicalScan(plan(numeric.exact()).of(data)?)) {
-            Some(result) => result, None => integers(Ints::U8(truth_bytes(data)))
-        },
+        Items::Compact(View::Booleans(data)) => {
+            let scan = plan(numeric.exact()).of(data)?;
+            match (scan.inverse, logical(p)) {
+                (false, Some(table)) => {
+                    let mut result = Vec::with_capacity(data.len());
+                    table.scan_along(data, scan.axis.dims(), scan.seed, &mut result);
+                    bool::build(scan.shape, result)
+                }
+                _ => match bool::dyad(p, scan) { Some(result) => result, None => integers(Ints::U8(truth_bytes(data))) },
+            }
+        }
         Items::Compact(View::Floats(data)) => with_floats!(kernel data, |data| float_scan(p, plan(numeric), data)),
         Items::Compact(View::Integers(ints)) => integers(ints),
         Items::Compact(View::Complexes(data)) => with_complexes!(data, |data| complex_scan(p, plan(numeric), data)),
@@ -1443,36 +1452,25 @@ impl<'a> ScanPlan<'a> {
     }
 }
 
-/// A scan of Booleans by a function that keeps them Boolean, through rustymath's scan of the function's truth table. The runner reads the table by calling the kernel on the four pairs of Booleans. An inverse scan, or a kernel that fails on a pair, runs through `Scan`.
-struct LogicalScan<'a>(Scan<'a, bool>);
-impl Dyad<bool> for LogicalScan<'_> {
-    type Output = Option<Value>;
-    fn numeric(&self) -> Numeric { self.0.numeric }
-    #[inline]
-    fn many(self, f: impl rustymath::Binary<bool, Out = bool> + Copy + Sync) -> Option<Value> {
-        let scan = self.0;
-        let row = |r| Some([f.checked(r, false)?, f.checked(r, true)?]);
-        let (false, Some(lo), Some(hi)) = (scan.inverse, row(false), row(true)) else { return scan.many(f) };
-        let mut result = Vec::with_capacity(scan.data.len());
-        reduce::Logical([lo, hi]).scan_along(scan.data, scan.axis.dims(), scan.seed, &mut result);
-        bool::build(scan.shape, result)
-    }
-    #[inline]
-    fn booleans(self, f: impl rustymath::Binary<bool, Out = bool> + Copy + Sync) -> Option<Value> { self.many(f) }
-}
+/// The truth table of `p`'s kernel on Booleans, where `p` has one that gives a Boolean for every pair. Folds and scans of Booleans by `p` run through it.
+fn logical(p: Primitive) -> Option<reduce::Logical> { bool::dyad(p, Truths)? }
 
-/// The truth table, indexed by `2*x+y`, of `p`'s kernel on Booleans, where `p` has one that gives a Boolean for every pair. A dyadic call, fold or scan of `gᵇ` with such a `g` runs as `Primitive::Bitwise` of the table (`Function::dyadic_primitive`).
-pub(crate) fn truth_table(p: Primitive) -> Option<u8> { bool::dyad(p, Truths)? }
+/// [`logical`]'s table, indexed by `2*x+y`. A dyadic call, fold or scan of `gᵇ` with such a `g` runs as `Primitive::Bitwise` of the table (`Function::dyadic_primitive`).
+pub(crate) fn truth_table(p: Primitive) -> Option<u8> {
+    let reduce::Logical(t) = logical(p)?;
+    Some((0..4).fold(0u8, |table, i| table | u8::from(t[i >> 1][i & 1]) << i))
+}
 
-/// The runner that reads a Boolean kernel's truth table for `truth_table`, by calling it on the four pairs of Booleans.
+/// The runner that reads a Boolean kernel's truth table for [`logical`], by calling it on the four pairs of Booleans.
 struct Truths;
 impl Dyad<bool> for Truths {
-    type Output = Option<u8>;
+    type Output = Option<reduce::Logical>;
     fn numeric(&self) -> Numeric { Numeric::EXACT }
-    fn many(self, f: impl rustymath::Binary<bool, Out = bool> + Copy + Sync) -> Option<u8> {
-        (0..4u8).try_fold(0, |table, i| Some(table | u8::from(f.checked(i & 2 != 0, i & 1 != 0)?) << i))
+    fn many(self, f: impl rustymath::Binary<bool, Out = bool> + Copy + Sync) -> Option<reduce::Logical> {
+        let row = |x| Some([f.checked(x, false)?, f.checked(x, true)?]);
+        Some(reduce::Logical([row(false)?, row(true)?]))
     }
-    fn booleans(self, f: impl rustymath::Binary<bool, Out = bool> + Copy + Sync) -> Option<u8> { self.many(f) }
+    fn booleans(self, f: impl rustymath::Binary<bool, Out = bool> + Copy + Sync) -> Option<reduce::Logical> { self.many(f) }
 }
 
 /// A scan of integers at their own width, or at rustymath's total type for a reduction: `⌈\`, `⌊\` and the scans of `ᵇ`'s and, or, xor and xnor run through rustymath's running reductions, and any other function through its kernel. `None` where a result doesn't fit.
@@ -1509,12 +1507,12 @@ struct Scan<'a, A> {
     data: &'a [A], seed: Option<A>, starts: Option<&'a [bool]>, axis: &'a Lanes, shape: Vec<usize>, numeric: Numeric, inverse: bool, flip: bool
 }
 impl<A: Stored> Scan<'_, A> {
-    /// The scan by `f`, which adds the next item to a running total.
+    /// The scan by `f` through rustymath's left scan, each running total stepped by the next item. `None` where a step fails, unless `kept` keeps its failed results, as `Fold::by` does.
     #[inline]
-    fn running(self, f: impl Fn(A, A) -> Option<A> + Copy + Sync) -> Option<Value> {
+    fn running<O: Element + Source<A>>(self, f: &impl rustymath::Binary<A, Out = O>) -> Option<Value> {
         if self.inverse { return None; }
         let mut result = Vec::with_capacity(self.data.len());
-        if !reduce::left_scan(self.data, self.axis.dims(), self.seed, f, &mut result) { return None; }
+        if !reduce::left_scan(f, self.data, self.axis.dims(), self.seed, &mut result) && !kept(f, self.numeric) { return None; }
         A::build_narrowed(self.shape, result)
     }
     /// The scan by rustymath's reduction `R` along the axis, at `R`'s total type, through `reduce::scan_along`. `None` where a result doesn't fit.
@@ -1572,13 +1570,13 @@ impl<A: Stored> Dyad<A> for Scan<'_, A> where bool: Source<A> {
     /// A scan runs through `running`, each step through `f`'s scalar form, and its inverse through `paired`, with `f`'s slice form.
     #[inline]
     fn many(self, f: impl rustymath::Binary<A, Out = A> + Copy + Sync) -> Option<Value> {
-        if self.inverse { self.paired(move |x, y, n, out| f.many(x, y, n, out)) } else { self.running(move |x, y| f.checked(x, y)) }
+        if self.inverse { self.paired(move |x, y, n, out| f.many(x, y, n, out)) } else { self.running(&f) }
     }
     /// A comparison runs through `compared`, with `f`'s slice form. Its inverse, and a scan from a seed of the items' type, which only functions other than comparisons get, step through `f`'s scalar form, with the Booleans converted back to the item type.
     #[inline]
     fn booleans(self, f: impl rustymath::Binary<A, Out = bool> + Copy + Sync) -> Option<Value> {
         if self.inverse { return self.paired(move |x, y, n, out| pairs(x, y, n, out, |a, b| item_result(f.checked(a, b).map(Source::<A>::read)))); }
-        if self.seed.is_some() { return self.running(move |x, y| f.checked(x, y).map(Source::<A>::read)); }
+        if self.seed.is_some() { return self.running(&f); }
         self.compared(&move |t, xs, out| f.many(t, Arg::Many(xs), xs.len(), out))
     }
 }
@@ -1696,6 +1694,11 @@ fn untransposed(s: Value, m: Mapping, shape @ [rows, _]: [usize; 2]) -> ((Value,
 fn native_fold(p: Primitive, data: View<'_>, dims: [usize; 3], tail: Option<View<'_>>, len: usize, numeric: Numeric) -> Option<Buffer> {
     match data {
         View::Booleans(data) => with_truth_reduction!(p, len, R => reduced::<_, R>(data, dims, tail, false)).flatten()
+            .or_else(|| {
+                if !reduce::Logical::folds(dims) { return None; }
+                let tail = match tail { Some(v) => Some(carried::<bool>(v)?), None => None };
+                Some(bool::buffer(logical(p)?.fold(data, dims[1], tail.as_deref())))
+            })
             .or_else(|| bool::dyad(p, Fold::new(data, dims, tail, Numeric::EXACT)?)?)
             .or_else(|| integer_fold(p, truth_bytes(data), dims, tail, numeric)),
         View::Integers(data) => with_ints!(data, |data| integer_fold(p, data, dims, tail, numeric)),
@@ -1710,10 +1713,10 @@ pub(crate) fn sliding(p: Primitive, data: View<'_>, dims: [usize; 3], width: usi
     with_reduction!(p, data, width, Numeric::current().is_static(), |data, R, kept| fitting(reduce::sliding::<_, R>(data, dims, width), kept))
 }
 
-/// The row of the first item that gives the maximum, for `⌈`, or the minimum, for `⌊`, of each window of `width` rows along the middle axis of `data`, an array of shape `dims`, as `sliding` folds the windows. Each row counts from the start of its lane. `None` for any other function, and for storage other than integers and 32- and 64-bit floats.
-pub(crate) fn sliding_picks(p: Primitive, data: View<'_>, dims: [usize; 3], width: usize) -> Option<Vec<usize>> {
+/// The row of the first item that gives the maximum, for `⌈`, or the minimum, for `⌊`, of each of the folds that `of` chooses along the middle axis of `data`, an array of shape `dims`. Each row counts from the start of its lane. `None` for any other function, and for storage other than Booleans, integers and 32- and 64-bit floats.
+pub(crate) fn picks(p: Primitive, data: View<'_>, dims: [usize; 3], of: reduce::Picks) -> Option<Vec<usize>> {
     let max = match p { Primitive::Math(Math::Ceiling) => true, Primitive::Math(Math::Floor) => false, _ => return None };
-    reduce::view_sliding_picks(data, dims, width, max)
+    reduce::view_picks(data, dims, of, max)
 }
 
 fn carried<A: Element>(view: View<'_>) -> Option<Cow<'_, [A]>> {