basedpl 0.1.40__tar.gz → 0.1.41__tar.gz

{basedpl-0.1.40 → basedpl-0.1.41}/.github/workflows/ci.yml

@@ -8,15 +8,20 @@ on:
 
 jobs:
   test:
-    runs-on: ubuntu-latest
+    # A `v*` tag runs this job and `wasm` on GitHub's runner, like the release jobs, without the speed tests. The speed budgets come from Ubicloud's runner.
+    runs-on: ${{ startsWith(github.ref, 'refs/tags/v') && 'ubuntu-latest' || 'ubicloud-standard-4' }}
     steps:
       - uses: actions/checkout@v7
       - run: node tests/input.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
+      # The `Speed` workflow restores this cache and the `wasm` job's, by their `shared-key`.
       - uses: Swatinem/rust-cache@v2
-      - run: cargo test
+        with:
+          shared-key: native
+      - run: grep -m1 'model name' /proc/cpuinfo
+      - run: cargo test -- ${{ startsWith(github.ref, 'refs/tags/v') && '--skip functions_cost_what_their_work_needs' || '' }}
       - uses: actions/setup-python@v7
         with:
           python-version: '3.12'
@@ -27,7 +32,7 @@ jobs:
       - run: nbdev-test
 
   wasm:
-    runs-on: ubuntu-latest
+    runs-on: ${{ startsWith(github.ref, 'refs/tags/v') && 'ubuntu-latest' || 'ubicloud-standard-4' }}
     steps:
       - uses: actions/checkout@v7
       - uses: dtolnay/rust-toolchain@stable
@@ -35,11 +40,16 @@ jobs:
           targets: wasm32-unknown-unknown
       - run: cargo generate-lockfile
       - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: wasm
       - run: cargo wasm --strip
       - run: node --test tests/wasm.mjs
-      - run: node --no-liftoff --test tests/wasm-speed.mjs
+      - run: grep -m1 'model name' /proc/cpuinfo
+      - if: ${{ !startsWith(github.ref, 'refs/tags/v') }}
+        run: node --no-liftoff --test tests/wasm-speed.mjs
       # The `npm` job publishes this package on a `v*` tag.
-      - uses: actions/upload-artifact@v7
+      - if: startsWith(github.ref, 'refs/tags/v')
+        uses: actions/upload-artifact@v7
         with:
           name: wasm-pkg
           path: wasm/pkg

basedpl-0.1.41/.github/workflows/speed.yml

@@ -0,0 +1,36 @@
+name: Speed
+
+on: workflow_dispatch
+
+permissions:
+  contents: read
+
+jobs:
+  native:
+    runs-on: ubicloud-standard-4
+    steps:
+      - uses: actions/checkout@v7
+      - uses: dtolnay/rust-toolchain@stable
+      - run: cargo generate-lockfile
+      # Only CI's `test` job saves this cache. This job builds only part of what `test` builds. GitHub never replaces a saved cache under the same key.
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: native
+          save-if: false
+      - run: grep -m1 'model name' /proc/cpuinfo
+      - run: BASEDPL_COSTS=1 cargo test --test speed -- --nocapture
+
+  wasm:
+    runs-on: ubicloud-standard-4
+    steps:
+      - uses: actions/checkout@v7
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: wasm32-unknown-unknown
+      - run: cargo generate-lockfile
+      - uses: Swatinem/rust-cache@v2
+        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.40 → basedpl-0.1.41}/Cargo.lock

@@ -87,7 +87,7 @@ checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 
 [[package]]
 name = "basedpl"
-version = "0.1.40"
+version = "0.1.41"
 dependencies = [
  "base64 0.23.1",
  "bytemuck",
@@ -133,7 +133,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-cli"
-version = "0.1.40"
+version = "0.1.41"
 dependencies = [
  "async-trait",
  "basedpl",
@@ -146,7 +146,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-py"
-version = "0.1.40"
+version = "0.1.41"
 dependencies = [
  "basedpl",
  "bytemuck",
@@ -161,7 +161,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-wasm"
-version = "0.1.40"
+version = "0.1.41"
 dependencies = [
  "basedpl",
  "js-sys",
@@ -1782,9 +1782,9 @@ dependencies = [
 
 [[package]]
 name = "rustymath"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fa6cb151bb850f07cfb59e53b5b4419a6e428474843814d4c9ad23e8d8c4c26"
+checksum = "45551e624b74066f0c0bf66b9110899e3e0c69d6b8dea0e70bc11b677da52241"
 dependencies = [
  "faer",
  "half",
@@ -2471,7 +2471,7 @@ checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
 
 [[package]]
 name = "xtask"
-version = "0.1.40"
+version = "0.1.41"
 dependencies = [
  "anyhow",
  "serde_json",

{basedpl-0.1.40 → basedpl-0.1.41}/Cargo.toml

@@ -2,7 +2,7 @@
 members = ["py"]
 
 [workspace.package]
-version = "0.1.40"
+version = "0.1.41"
 edition = "2021"
 rust-version = "1.98"
 license = "Apache-2.0"
@@ -51,7 +51,7 @@ num-complex = { version = ">=0.4.6, <1", features = ["bytemuck"] }
 num-bigint = ">=0.4.6, <0.5"
 num-traits = ">=0.2.19, <1"
 half = { version = ">=2.7.1, <3", features = ["num-traits", "bytemuck"] }
-rustymath = ">=0.1.6, <1"
+rustymath = ">=0.1.9, <1"
 strength_reduce = ">=0.2.4, <1"
 rand = ">=0.10.2, <1"
 faer = { version = ">=0.24.4, <1", default-features = false, features = ["std", "linalg"] }

{basedpl-0.1.40 → basedpl-0.1.41}/PKG-INFO

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

{basedpl-0.1.40 → basedpl-0.1.41}/nbs/glyphs/ceiling.qmd

@@ -9,8 +9,9 @@ Keys: `Alt-s`. Ranks: `0` monadic, `0 0` dyadic
 ⌈3r2              ⍝ 2ₓ
 ```
 
-`X⌈Y` takes the real maximum. Pervasive. Beside NaN it returns the other argument, as Rust's `f64::max` does. Empty reduction identity: `¯∞`.
+`X⌈Y` takes the real maximum. Pervasive. Beside NaN it gives NaN, as NumPy's `maximum` does. Empty reduction identity: `¯∞`.
 
 ```bpl
 3⌈1 5             ⍝ 3 5
+3⌈1 $n 5          ⍝ 3 $n 5
 ```

{basedpl-0.1.40 → basedpl-0.1.41}/nbs/glyphs/floor.qmd

@@ -15,8 +15,9 @@ Complex floor uses APL's Gaussian-integer rule.
 ⌊1.5j0.5          ⍝ 1j1
 ```
 
-`X⌊Y` takes the real minimum. Pervasive. Beside NaN it returns the other argument, as Rust's `f64::min` does. Empty reduction identity: `∞`.
+`X⌊Y` takes the real minimum. Pervasive. Beside NaN it gives NaN, as NumPy's `minimum` does. Empty reduction identity: `∞`.
 
 ```bpl
 3⌊1 5             ⍝ 1 3
+3⌊1 $n 5          ⍝ 1 $n 3
 ```

{basedpl-0.1.40 → basedpl-0.1.41}/nbs/numbers.qmd

@@ -177,11 +177,11 @@ Joining infinities or NaN to exact integers keeps the integers exact. Exact inte
 
 CSV and JSON imports give NaN for a missing number. An integer column with gaps then stays exact.
 
-`⌊` and `⌈` return an exact argument unchanged beside an infinity, and return the other argument beside NaN:
+`⌊` and `⌈` return an exact argument unchanged beside an infinity. Beside NaN they give NaN:
 
 ```bpl
 3ₓ⌊∞                 ⍝ 3ₓ
-3ₓ⌊$n                ⍝ 3ₓ
+3ₓ⌊$n                ⍝ $n
 ```
 
 Arithmetic with an infinity gives floats.

{basedpl-0.1.40 → basedpl-0.1.41}/src/number.rs

@@ -754,14 +754,13 @@ 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) }))); }
-        // As in Rust's `max` and `min`, NaN gives way to the other argument. An exact number stays exact beside an infinity, and beside
+        // 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.
-        if self.is_nan() { return Ok(right.clone()); }
-        if right.is_nan() { return Ok(self.clone()); }
-        if (self.is_exact() && right.is_exact()) || self.is_infinite() || right.is_infinite() {
+        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());
         }
-        reals!(self, right => |x, y: F| Ok(Self::from_float(if maximum { x.max(y) } else { x.min(y) })))
+        reals!(self, right => |x, y: F| Ok(Self::from_float(if maximum { rustymath::reduce::maximum(x, y) } else { rustymath::reduce::minimum(x, y) })))
     }
 
     /// The result at the first of four levels that gives one for `self` and `right`: both 64-bit integers, both exact, both real, and

{basedpl-0.1.40 → basedpl-0.1.41}/src/pervasive.rs

@@ -209,8 +209,8 @@ mod float_arithmetic {
             Primitive::Arithmetic(Minus) => run.same(|x, y| Some(x - y)),
             Primitive::Arithmetic(Times) => run.same(|x, y| Some(x * y)),
             Primitive::Arithmetic(Divide) => run.same(|x, y| Some(x / y)),
-            Primitive::Math(Ceiling) => run.same(|x: F, y| Some(x.max(y))),
-            Primitive::Math(Floor) => run.same(|x: F, y| Some(x.min(y))),
+            Primitive::Math(Ceiling) => run.same(|x: F, y| Some(reduce::maximum(x, y))),
+            Primitive::Math(Floor) => run.same(|x: F, y| Some(reduce::minimum(x, y))),
             Primitive::Math(Magnitude) => with_tolerance!(t, |t| run.same(move |x: F, y: F| Some(t.residue(x, y)))),
             Primitive::Compare(op) => with_tolerance!(t, |t| compare(op, run, t)),
             _ => return None,
@@ -991,7 +991,7 @@ impl<A: Element, X: Element, Y: Source<A>> Monad<A> for Map<'_, X, Y> {
 }
 
 /// A loop over integers where an argument holds a non-finite value, read as `extended` defines them. Beside such a value, arithmetic
-/// gives `extended::arithmetic`. Comparisons, `⌊` and `⌈` follow IEEE: NaN is unordered and gives way to the other argument. Monadic
+/// gives `extended::arithmetic`. Comparisons follow IEEE: NaN is unordered. `⌊` and `⌈` give NaN beside NaN, as they do on floats. Monadic
 /// `+ ⌊ ⌈` keep every value, `×` keeps NaN, and `-` and `|` act on the float the value stands for. Other kernels give up there. `seen`
 /// records whether any result is non-finite.
 struct Nonfinite<'a, R> { run: R, p: Primitive, seen: &'a Cell<bool> }
@@ -1006,7 +1006,7 @@ impl<R: Dyad<i64>> Dyad<i64> for Nonfinite<'_, R> {
             Primitive::Math(Math::Floor | Math::Ceiling) => self.run.same(move |x, y| {
                 note(
                     seen,
-                    if extended::is_nan(x) { Some(y) } else if extended::is_nan(y) { Some(x) } else { f(x, y) },
+                    if extended::is_nan(x) { Some(x) } else if extended::is_nan(y) { Some(y) } else { f(x, y) },
                 )
             }),
             Primitive::Arithmetic(op) => self.run.same(move |x, y| note(seen, if special(x, y) { extended::arithmetic(op, x, y) } else { f(x, y) })),
@@ -1091,8 +1091,8 @@ pub(crate) fn fold(p: Primitive, right: &Value, axis: &Axis, shape: Vec<usize>,
     }
 }
 
-/// A reduction of floats of width `F`. `+/` and `×/` use algebraic operations, which may combine the items in any order. NaN gives way
-/// in `max` and `min`, so each lane of `⌈/` or `⌊/` can start from it.
+/// A reduction of floats of width `F`. `+/` and `×/` use algebraic operations, which may combine the items in any order. Each lane of
+/// `⌈/` starts from ¯∞ and each lane of `⌊/` from ∞. A NaN item makes its lane's result NaN.
 fn float_fold<F: Float + Native + Kernels + reduce::Fold<Sum = F>>(p: Primitive, data: &[F], axis: &Axis, shape: Vec<usize>, numeric: Numeric) -> Option<Value>
 where
     bool: Source<F>,
@@ -1102,8 +1102,8 @@ where
     match p {
         Primitive::Arithmetic(Plus) => F::build_narrowed(shape, lanes(data, axis, F::zero(), F::algebraic_add, |l| total(reduce::sum(l)))),
         Primitive::Arithmetic(Times) => F::build_narrowed(shape, lanes(data, axis, F::one(), F::algebraic_mul, |l| total(reduce::prod(l)))),
-        Primitive::Math(Ceiling) => F::build_narrowed(shape, lanes(data, axis, F::nan(), F::max, reduce::max)),
-        Primitive::Math(Floor) => F::build_narrowed(shape, lanes(data, axis, F::nan(), F::min, reduce::min)),
+        Primitive::Math(Ceiling) => F::build_narrowed(shape, lanes(data, axis, F::neg_infinity(), reduce::maximum, reduce::max)),
+        Primitive::Math(Floor) => F::build_narrowed(shape, lanes(data, axis, F::infinity(), reduce::minimum, reduce::min)),
         _ => F::dyad(p, Fold { data, axis, shape, numeric })?,
     }
 }
@@ -1305,8 +1305,8 @@ where
     match p {
         Primitive::Arithmetic(Arithmetic::Plus) => scan.sliced(|x, y| x + y, |l, s, o| { reduce::cumsum(l, s, o); }),
         Primitive::Arithmetic(Arithmetic::Times) => scan.sliced(|x, y| x * y, |l, s, o| { reduce::cumprod(l, s, o); }),
-        Primitive::Math(Math::Ceiling) => scan.sliced(num_traits::Float::max, reduce::cummax),
-        Primitive::Math(Math::Floor) => scan.sliced(num_traits::Float::min, reduce::cummin),
+        Primitive::Math(Math::Ceiling) => scan.sliced(reduce::maximum, reduce::cummax),
+        Primitive::Math(Math::Floor) => scan.sliced(reduce::minimum, reduce::cummin),
         _ => F::dyad(p, scan)?,
     }
 }

{basedpl-0.1.40 → basedpl-0.1.41}/tests/speed.txt

@@ -1,6 +1,6 @@
 # The cases that `tests/speed.rs` times in the native build and `tests/wasm-speed.mjs` times in the browser build. Each case line holds the code, its native budget and its wasm budget, separated by tabs. Each section starts with its name in brackets and the prefs its session starts with. Every session then runs the lines under `[setup]`.
 # Budgets in `[copies]` and `[exact]` count copies of the same data. A budget in `[widths]` is the most that the time in that section's 32-bit session may be, as a fraction of the time in the `[exact]` session. Natively and in wasm, it is the worse of that fraction on a Mac and on CI's runner, plus 0.25.
-# A wasm budget in copies is twice the most the case has cost on a Mac in the module that `cargo wasm` builds, and at least 0.5. `tests/speed.rs` gives the rule for native budgets in copies.
+# A wasm budget in copies is twice the most the case has cost on a Mac and on CI's runner, in the module that `cargo wasm` builds, and at least 0.5. `tests/speed.rs` gives the same rule for native budgets in copies. CI's Ubicloud runner hasn't timed the cases yet, so the CI figures come from GitHub's runner, in `Speed` run 38184659294. A CI wasm job on the same code cost about 2.5 times that run's wasm figures, so each wasm figure counts 2.5 times. `⌈/v`, `⌈\v` and `v⌊w` changed after that run, and the Mac's costs stand in for CI's.
 [setup]
 side←256 ⋄ n←side×side ⋄ v←¿n⍴0 ⋄ w←¿n⍴0 ⋄ s←v-0.5 ⋄ m←[side side]⍴v
 jv←¿n⍴1000ₓ ⋄ kv←¿n⍴1000000000000ₓ ⋄ b←0=¿n⍴3ₓ ⋄ i←¿n⍴⌊n
@@ -16,142 +16,142 @@ nd←•distribution "normal" ⋄ coeffs←0.5 ¯1.25 0.75 2 ¯0.125 0.0625 ¯1.
 ⌈/v	2.9	15
 ∧/b	0.6	3.4
 +/m	2.5	5.7
-+⌿m	3.4	4
++⌿m	3.4	5
 # Reading one argument and writing each item once.
--v	2.8	3.8
+-v	3	6
 -jv	2.1	2.2
 ~b	0.5	1.1
 ∧\b	0.5	0.96
 ∨\b	0.5	1.1
-⌽v	2.8	3.7
-1⌽v	3.4	3.9
-⊖m	3.6	5.9
-1↓v	3.7	4.2
-(n÷2)↑v	2.2	2.9
+⌽v	3	7.9
+1⌽v	3.4	5.4
+⊖m	3.8	6.9
+1↓v	3.7	4.3
+(n÷2)↑v	2.2	3.3
 n⍴0	1.8	3.6
 # Reading two arguments and writing each item once.
-v+w	4.6	5.3
+v+w	4.6	9.7
 jv+jv	2.7	2.7
-kv+kv	4.6	6.4
-v×2	2.8	4
-jv×2	2.6	3.8
+kv+kv	4.9	14
+v×2	3.1	4.8
+jv×2	2.6	5.1
 jv=jv	2.0	2.3
-b×jv	3.2	4.6
-b×kv	4.7	6.6
+b×jv	3.2	11
+b×kv	4.7	13
 v⌊w	4.6	14
 b∧b	1.2	1.5
-c=c	1.4	3.3
+c=c	1.4	6.8
 (⍳√n)×⊗⍳√n	4.0	4.7
 # Compressing by a mask can't be vectorised, because each kept item's place depends on the items before it.
-b#v	5.8	12
-⍸b	6.1	9.3
+b#v	6.7	14
+⍸b	6.1	11
 # A range with an approximate length converts each position from an integer to a float.
 ⍳n	2.1	5.9
 # Comparing within tolerance takes a subtraction, the magnitudes, a scale and a comparison for each item.
 ⌊v	18.0	55
-v<w	11.0	23
+v<w	11.0	30
 jv<500	7.0	2.5
 # Writing twice as many items, or writing in a different order from reading.
-v,w	4.6	5.8
-⍉m	21.0	18
+v,w	4.6	11
+⍉m	21.0	29
 # A small-table index takes one pass for the range of the items, then one pass to write each item's first position into the
 # table. Each of these passes costs 1.4 to 2.5 copies, because a table read or write can't be vectorised.
-≠jv	8.8	20
+≠jv	9.6	21
 # A search also looks each item of the other argument up in the table, and unique then compresses by the mask.
-jv⍳jv	19.0	34
-jv∊jv	19.0	33
-c⍳c	19.0	31
+jv⍳jv	20	37
+jv∊jv	19.0	37
+c⍳c	20	36
 ∪jv	15.0	29
 ∪c	17.0	28
 # Key classifies the keys, counts and places each group's positions, then gathers each group's items.
-{≢⍵}⌸b	73.0	96
+{≢⍵}⌸b	73.0	140
 # Each item waits for the result before it. In float scans by `+` and `⌈`, only one item in each group of four waits for the group
 # before it.
-+\v	5.3	6.2
-⌈\v	8.1	26
-+\jv	13.0	25
-+\b	7.4	12
-≠\b	5.8	7.1
++\v	5.3	6.5
+⌈\v	8.1	42
++\jv	14	27
++\b	7.4	18
+≠\b	6.6	9.8
 # Each item waits for a read from a random place.
-[i]⌷v	16.0	18
+[i]⌷v	16.0	29
 # An approximate divisor reads the integers as floats. Each item then needs a float division and a floor within tolerance.
-3|jv	21.0	170
+3|jv	27	170
 # rustymath's `exp` evaluates a polynomial of 10 terms for each item, and `ln` one of 7 terms and a division.
-*s	23.0	39
-⍟v	31.0	46
+*s	23.0	57
+⍟v	33	96
 # rustymath's sine and cosine reduce each item by π in three fused multiply-adds, and evaluate a polynomial of 7 terms. Tangent
 # reduces by π/2, evaluates a polynomial of 9 terms at half the angle, and divides once.
-1○v	17.0	63
-2○v	20.0	41
-3○v	26.0	51
+1○v	20	68
+2○v	23	75
+3○v	26.0	110
 # The hyperbolic functions build on rustymath's `exp` and `expm1`, with a division. The inverse circle functions evaluate a
 # polynomial of 10 or 12 terms after a reduction with a square root or a division.
-5○v	31.0	56
-6○v	23.0	43
-7○v	31.0	57
-1○⁻¹v	24.0	46
-2○⁻¹v	65.0	44
-3○⁻¹v	23.0	41
+5○v	32	110
+6○v	24	65
+7○v	31.0	88
+1○⁻¹v	24.0	71
+2○⁻¹v	65.0	92
+3○⁻¹v	23.0	93
 # The inverse hyperbolic functions build on rustymath's `log1p`, after a square root or a division.
-5○⁻¹v	48.0	67
-4○v	13.0	18
+5○⁻¹v	48.0	110
+4○v	13.0	19
 # An exponent of 2 squares each item, in a loop of its own. Another exponent calls rustymath's `pow` for each item, which at f64
 # reads tables that NEON and wasm can't vectorize.
-v*2	3.2	4.1
+v*2	3.2	4.9
 v*w	130.0	210
 # Bases 2 and 10 and degrees 2 and 3 have loops of their own.
-2⍟v	33.0	49
-10⍟v	34.0	50
-3√v	27.0	61
+2⍟v	33.0	77
+10⍟v	34.0	98
+3√v	28	98
 # Exact integers read as floats for a function whose results are always approximate.
-⍟jv	35	53
-*jv	23	44
-jv⍟2ₓ	140	130
-√jv	7.5	10
+⍟jv	35	96
+*jv	23	69
+jv⍟2ₓ	140	290
+√jv	7.5	26
 # `!` calls rustymath's `gamma`, which sums its Lanczos series in double words. A distribution's density, cdf and quantile each
 # run over the array as one slice. The quantile refines Giles's approximation of erfcinv with Halley steps. `⌻` evaluates a
 # polynomial of degree 7 by Horner's rule.
-!v	430	860
-nd.density v	70	100
-nd.cdf v	62	77
-nd.quantile v	690	1090
+!v	450	1400
+nd.density v	70	120
+nd.cdf v	62	140
+nd.quantile v	690	1100
 coeffs⌻v	12	34
 # Each item goes into a hash table, and each item of the other argument is looked up in it. A tolerant search looks in two
 # buckets for each item, where an exact search looks in one.
 v⍳w	710.0	830
 # A radix sort moves every item once for each byte that differs between the keys.
-⍋v	280.0	210
-⍋jv	110.0	140
+⍋v	280.0	360
+⍋jv	110.0	190
 # Unique sorts the reals, then compares each with the next one.
-∪v	320.0	350
+∪v	320.0	540
 [exact] •prefs ["tolerance":0]
 # Plain IEEE comparisons and `floor`, with nothing to scale by a tolerance.
 ⌊v	5.0	15
-v<w	3.0	5.9
-v=w	3.2	5.7
-3|v	5.8	36
+v<w	3.2	9.3
+v=w	3.2	7.8
+3|v	8.5	36
 # Each real indexes its `order_key` in a hash map, as exact data does.
-v⍳w	340.0	250
+v⍳w	340.0	260
 ∪v	410.0	260
 [widths] •prefs ["float":32]
 # Half the bytes to read and write, and twice the lanes in each SIMD instruction.
 -v	0.82	0.89
 v+w	0.78	0.85
 v×2	0.83	0.89
-v<w	0.82	0.88
+v<w	0.83	0.88
 0.5<v	0.87	0.87
-√v	0.78	0.86
+√v	0.79	0.86
 +⌿m	0.89	0.99
 +/v	0.88	0.77
 ⌈/v	0.91	1.26
 m+.×m	0.87	1.26
 # `⌊` reads half the bytes and writes 32-bit integers in place of 64-bit ones.
-⌊v	0.89	1.03
+⌊v	0.89	1.05
 # An LU decomposition in 32 bits.
 ⌹m	0.99	1.23
 # rustymath's `exp` and `ln` run shorter polynomials at f32, with twice the lanes in each SIMD instruction.
-*s	0.65	0.61
-⍟v	0.68	0.64
+*s	0.66	0.61
+⍟v	0.69	0.64
 # rustymath's sine and cosine reduce in f32 with fused multiply-adds, and run a polynomial of 4 terms in place of 7.
 1○v	0.71	1.01
 2○v	0.74	0.98
@@ -159,10 +159,10 @@ m+.×m	0.87	1.26
 7○v	0.7	0.61
 1○⁻¹v	0.64	0.56
 3○⁻¹v	0.69	0.57
-v*2	0.82	0.93
+v*2	0.82	1.08
 v*w	0.8	0.93
 # Grade sorts keys and positions of half the bytes.
-⍋v	0.94	0.89
+⍋v	0.98	0.92
 # A hash lookup costs about the same at either width. These budgets catch a 32-bit search that costs much more than a 64-bit one.
-v⍳w	1.17	1.23
+v⍳w	1.18	1.23
 ∪v	1.2	1.33

basedpl-0.1.40/.github/workflows/speed.yml

@@ -1,23 +0,0 @@
-name: Speed
-
-on: workflow_dispatch
-
-permissions:
-  contents: read
-
-jobs:
-  costs:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: wasm32-unknown-unknown
-      - run: cargo generate-lockfile
-      - uses: Swatinem/rust-cache@v2
-      - run: BASEDPL_COSTS=1 cargo test --test speed -- --nocapture
-      # The wasm costs print even when a native case goes over budget.
-      - if: ${{ !cancelled() }}
-        run: cargo wasm --strip
-      - if: ${{ !cancelled() }}
-        run: BASEDPL_COSTS=1 node --no-liftoff tests/wasm-speed.mjs