basedpl 0.1.74__tar.gz → 0.1.75__tar.gz

{basedpl-0.1.74 → basedpl-0.1.75}/Cargo.lock

@@ -93,7 +93,7 @@ checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 
 [[package]]
 name = "basedpl"
-version = "0.1.74"
+version = "0.1.75"
 dependencies = [
  "base64 0.23.1",
  "bytemuck",
@@ -137,7 +137,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-cli"
-version = "0.1.74"
+version = "0.1.75"
 dependencies = [
  "async-trait",
  "basedpl",
@@ -151,7 +151,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-py"
-version = "0.1.74"
+version = "0.1.75"
 dependencies = [
  "basedpl",
  "num-bigint",
@@ -166,7 +166,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-wasm"
-version = "0.1.74"
+version = "0.1.75"
 dependencies = [
  "basedpl",
  "js-sys",
@@ -1415,9 +1415,9 @@ dependencies = [
 
 [[package]]
 name = "rustymath"
-version = "0.1.49"
+version = "0.1.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9aedcee908443b05f25913ad641d665c8388e8de7aca5f5aa16d10eeffec475"
+checksum = "335ad6719521b80cd2d57195ca4ee58d7997a8190121ff9adeff263e75fa8b0a"
 dependencies = [
  "foldhash",
  "half",
@@ -1436,9 +1436,9 @@ dependencies = [
 
 [[package]]
 name = "rustymath-buffer"
-version = "0.1.49"
+version = "0.1.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4c19ddeaf8f211645269dfb77fd01c26b4a4e268f150ea473677fee942c7ee1"
+checksum = "2f2147d26a5e6ac6ac4af4eae28d572fb8c285074f2f5058c2d04b779884c371"
 dependencies = [
  "pyo3",
  "rustymath",
@@ -2088,7 +2088,7 @@ checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
 
 [[package]]
 name = "xtask"
-version = "0.1.74"
+version = "0.1.75"
 dependencies = [
  "anyhow",
  "rustymath",

{basedpl-0.1.74 → basedpl-0.1.75}/Cargo.toml

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

{basedpl-0.1.74 → basedpl-0.1.75}/DEV.md

@@ -24,7 +24,7 @@ Build nothing else without discussion: no scratch crates, alternate target direc
 
 When another agent's unfinished edits stop the shared tree compiling, run `cargo wait` with the Bash tool's `run_in_background`, then build after it exits. `cargo wait` comes from `fastws-cli`, as `cargo develop` does. It runs `cargo check` on every target of the workspace each time a source file or manifest of a local package changes, rustymath's included. It exits once the tree compiles, or after 30 minutes with the remaining errors. `cargo wait --path ~/aai-ws/rustymath` waits for rustymath's own workspace, its Python extension included. Use it rather than writing a wait loop.
 
-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.
+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. A list of expressions runs each in its own fresh worker and gives one row for each, holding its output or its error. `prefs=` runs before the code in each worker, as in `fresh(cases, prefs='•prefs ["kinds":"static"]')`. 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. `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/*.bpl`. `cases=` selects expressions, `wasm=DIR` selects a browser build, `bpl=PATH` selects another native `bpl`, such as a saved copy, `native=True` times rustymath's own linear algebra, which dev builds compile in, and `prefs=` runs BPL before each section's header, such as `•prefs ["kinds":"static"]`. `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.
 
@@ -180,7 +180,7 @@ Float operations compute at the wider operand width. Exact operands round to the
 
 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`. Comparisons, `⌈ ⌊` and bitwise functions compute at their arguments' storage width instead, where their results are the same at every width (`pervasive::first_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.
+Under `•prefs ["kinds":"static"]`, a result's kind follows from its arguments' kinds alone, as `meta/kinds.md` describes. `Numeric` carries `kinds` and `int`. Until the `float` pref sets a width, `Numeric::set` gives new floats the width the kinds give, 32 bits under static kinds and 64 under dynamic kinds (`Kinds::float_width`). Whether the pref has set one lives in `settings::float_set`, outside `Numeric`: every call builds and copies a `Numeric`, and a Boolean field there cost about 14 instructions on each primitive call and 34 on each dfn call. `pervasive::map` chooses a dyadic call's kind through `joined`, which applies rustymath's `DType::common` after `Numeric::kind`. Comparisons, `⌈ ⌊` and bitwise functions compute at their arguments' storage width instead, where their results are the same at every width (`pervasive::first_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::wrapped` and `Value::wrapped` wrap an exact integer result to the integer width, the fixed width that `Numeric::for_values` finds among a call's arguments or the `int` width under static kinds. `statically` uses them, and so do the functions that compute exactly, such as `⊥`, `⌻` and the determinant. `Number::parse` keeps complex literals and checks integer literals against the `int` width.
 
 Settings live once for the whole process, in `settings.rs`, and are read from there, not passed through functions, except where a read is slow and on a hot path. Each setting that calls and scalar operations read is an atomic: the numeric settings, the hanzi aliases, the `batch` pref, the fusion report flag and fusion's small sizes. The display settings sit behind one lock. `•prefs` writes them, the lexer writes a source's leading `•prefs` header as it reads it, and `settings::reset` restores the defaults, as `]clear` and the test harnesses do. Nothing copies, captures or restores a setting. A pending array computes under the settings in force when it computes, and a module that `•load` runs changes the settings for the whole process. Rustymath holds the thread count, the one setting that it reads itself, and `•prefs` writes it there. Each call reads the store once where it starts: `pervasive::halves`, which every `pervasive` entry point goes through, `fusion::defers` and `defer`, `Domain::of`, the lexer and `Storage::item`'s complex items. Values derived from the settings within a call stay explicit arguments. `halves` passes 16-bit floats' widened settings to its inner call. The loop structs keep them because their closures run on rustymath's worker threads. A fused graph reads the settings once when it's built at forcing, for the same reason. `Number`'s tolerance methods and `Primitive::number` take them because they run once per item. The parser's leaves take a width marker's width, and `matches_within` takes `⍣∞`'s convergence tolerance. Imports build complex numbers with `Number::complex_in_session`: Python's `_Session.array` and the JSON protocol's `request`. JavaScript values hold no complex numbers.
 

{basedpl-0.1.74 → basedpl-0.1.75}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basedpl
-Version: 0.1.74
+Version: 0.1.75
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: fastcore
@@ -98,10 +98,10 @@ avg 1 2 3 4
 
     2.5
 
-To see how these ideas express an algorithm, start from “a prime has exactly two positive divisors”. Form all remainders of 1 to 50 (`|⊗⍨↦50`), count the zeros down each column (`+⌿0=`), and find the positions (`⍸`) whose count is two. Positions count from 0. `≥` increments each position to recover its number:
+To see how these ideas express an algorithm, start from “a prime has exactly two positive divisors”. Form all remainders of 1 to 50 (`|⊗⍨↦50ₓ`), count the zeros down each column (`+⌿0ₓ=`), and find the positions (`⍸`) whose count is two. Positions count from 0. `≥` increments each position to recover its number:
 
 ``` bpl
-≥⍸2=+⌿0=|⊗⍨↦50
+≥⍸2ₓ=+⌿0ₓ=|⊗⍨↦50ₓ
 ```
 
     [2 3 5 7 11 13 17 19 23 29 31 37 41 43 47]ₓ
@@ -185,7 +185,7 @@ A vector of counts keeps the history: one state for each count, where count 0 is
 Under (`@`) transforms the argument, applies a function, then reverses the transformation. Scale by ten, floor, and scale back to round down to tenths:
 
 ``` bpl
-⌊@ 10× 1.25 2.78
+⌊@(10×)1.25 2.78
 ```
 
     1.2 2.7

{basedpl-0.1.74 → basedpl-0.1.75}/README.md

@@ -68,10 +68,10 @@ avg 1 2 3 4
 
     2.5
 
-To see how these ideas express an algorithm, start from “a prime has exactly two positive divisors”. Form all remainders of 1 to 50 (`|⊗⍨↦50`), count the zeros down each column (`+⌿0=`), and find the positions (`⍸`) whose count is two. Positions count from 0. `≥` increments each position to recover its number:
+To see how these ideas express an algorithm, start from “a prime has exactly two positive divisors”. Form all remainders of 1 to 50 (`|⊗⍨↦50ₓ`), count the zeros down each column (`+⌿0ₓ=`), and find the positions (`⍸`) whose count is two. Positions count from 0. `≥` increments each position to recover its number:
 
 ``` bpl
-≥⍸2=+⌿0=|⊗⍨↦50
+≥⍸2ₓ=+⌿0ₓ=|⊗⍨↦50ₓ
 ```
 
     [2 3 5 7 11 13 17 19 23 29 31 37 41 43 47]ₓ
@@ -155,7 +155,7 @@ A vector of counts keeps the history: one state for each count, where count 0 is
 Under (`@`) transforms the argument, applies a function, then reverses the transformation. Scale by ten, floor, and scale back to round down to tenths:
 
 ``` bpl
-⌊@ 10× 1.25 2.78
+⌊@(10×)1.25 2.78
 ```
 
     1.2 2.7

{basedpl-0.1.74 → basedpl-0.1.75}/lib/array.bpl

@@ -39,9 +39,9 @@ format ← {t←⊃,↓⍬⍕⍵ ⋄ (¯2↑1 1,⍴t)⍴t}  ⍝ Simple array as
 open ← {(1⌈⍴⍵)⍴⍵}  ⍝ Exposure of null axes.
 axes ← {(-2⌈⍴⍴⍵)↑≥×⍴⍵}  ⍝ Array axis types.
 char ← {⍬≡⍴⍵?'─';(↑⍵∊'¯',$d)⊃"#~"}∘⍕  ⍝ Type character of an atom.
-type ← {{(1=⍴⍵)⊃['+' ⍵]}∪,char¨⍵}  ⍝ Type characters of an array.
+type ← {{(1ₓ=⍴⍵)⊃['+' ⍵]}∪,char¨⍵}  ⍝ Type characters of an array.
 deco ← {⍺←type open ⍵ ⋄ ⍺,axes ⍵}  ⍝ Type and axes vector.
-trim ← {(~1 1⍷∧⌿⍵=' ')#⍠¯1 ⍵}  ⍝ Removal of extra blank columns.
+trim ← {(~$t $t⍷∧⌿⍵=' ')#⍠¯1 ⍵}  ⍝ Removal of extra blank columns.
 
 ⍝ From http://dfns.dyalog.com/c_disp.htm
 
@@ -49,10 +49,10 @@ disp ← { ⍺←⍬  ⍝ Boxed sketch of nested array.
   [dec ctd]←2↑⍺  ⍝ 1:decorated, 1:centred.
   box←{  ⍝ Recursive boxing of nested array.
     isor ⍵?format⊂⍵;
-    1=≡,⍵?dec open format dec open ⍵;
+    1ₓ=≡,⍵?dec open format dec open ⍵;
     mat←matr 1# dec open ⍵  ⍝ matrix of opened subarrays.
     [r c]←×⍴mat  ⍝ non-null rows/cols.
-    dec<0∊[r c]?c#⍠¯1 r# ∇ 1 open mat;  ⍝ undecorated null: empty result.
+    dec<0ₓ∊[r c]?c#⍠¯1 r# ∇ 1 open mat;  ⍝ undecorated null: empty result.
     subs←aligned ∇¨mat  ⍝ aligned boxed subarrays.
     (≢⍴⍵)gaps ⍵ plane subs  ⍝ collection into single plane.
   }
@@ -64,21 +64,21 @@ disp ← { ⍺←⍬  ⍝ Boxed sketch of nested array.
     v⊖¨h⌽¨sizes↑¨⍵  ⍝ centred aligned subarrays.
   }
   gaps←{  ⍝ Gap-separated sub-planes.
-    ⍺≤2?⍵;  ⍝ lowish rank: done.
+    ⍺≤2ₓ?⍵;  ⍝ lowish rank: done.
     subs←(≤⍺)∇¨⍵  ⍝ sub-hyperplanes.
     width←↑⌽⍴↑subs
     fill←([⍺ width]-3 0)⍴' '  ⍝ inter-plane gap.
     ⊃{⍺⍪fill⍪⍵}/ 1 open subs
   }
   plane←{  ⍝ Boxed rank-2 plane.
-    2<⍴⍴⍺?⍺ join ⍵;  ⍝ gap-separated sub-planes.
+    2ₓ<⍴⍴⍺?⍺ join ⍵;  ⍝ gap-separated sub-planes.
     odec←(dec shape ⍺)outer ⍵  ⍝ outer type and shape decoration.
     idec←inner ⍺  ⍝ inner type and shape decorations.
     (odec,idec)collect ⍵  ⍝ collected, formatted subarrays.
   }
   join←{  ⍝ Join of gap-separated sub-planes.
-    sep←(≢⍵)÷1⌈≢⍺  ⍝ sub plane separation.
-    split←(0=sep|⍳≢⍵)⊂⍠0 ⍵
+    sep←(≢⍵)÷1ₓ⌈≢⍺  ⍝ sub plane separation.
+    split←(0ₓ=sep|⍳≢⍵)⊂⍠0 ⍵
     (⊂⍤¯1 ⍺)plane¨split  ⍝ sub-plane join.
   }
   outer←{  ⍝ Outer decoration.
@@ -112,14 +112,14 @@ disp ← { ⍺←⍬  ⍝ Boxed sketch of nested array.
     dec<≡⍵?'─';  ⍝ nested: '─'
     isor ⍵?'∇';  ⍝ ⎕or:    '∇'
     sst←{  ⍝ atom type.
-      0=dec×⍴⍴⍵?'─';  ⍝ undecorated or atom ⍕⍵: char,
+      0ₓ=dec×⍴⍴⍵?'─';  ⍝ undecorated or atom ⍕⍵: char,
       (↑⍵∊'¯',$d)⊃"#~"
     }∘⍕  ⍝ ⍕ distinguishes type of atom.
-    0=≡⍵?sst ⍵;  ⍝ atom: type.
-    {(1=⍴⍵)⊃['+' ⍵]}∪,sst¨(dec open ⍵)
+    0ₓ=≡⍵?sst ⍵;  ⍝ atom: type.
+    {(1ₓ=⍴⍵)⊃['+' ⍵]}∪,sst¨(dec open ⍵)
   }
   shape←{
-    dec≤0=⍴⍴⍵?⍺#¨"│─";  ⍝ no decoration or unit.
+    dec≤0ₓ=⍴⍴⍵?⍺#¨"│─";  ⍝ no decoration or unit.
     cols←(ׯ1↑⍴⍵)⊃"⊖→"
     rsig←(××/¯1↓⍴⍵)⊃"⌽↓"
     rows←(≤3⌊⍴⍴⍵)⊃['│' rsig '⍒']
@@ -128,10 +128,10 @@ disp ← { ⍺←⍬  ⍝ Boxed sketch of nested array.
   matr←{⊃,↓⍵}
   sepr←{+/¨1⊂⍠¯1 ⊃⍵}
   open←{(⍺⌈⍴⍵)↑⍵}
-  isor←{1 ⍬≡[≡⍵ ⍴⍵]}  ⍝ is ⎕or of object?
-  glue←{0=⍴⍵?⍵;⍺{⍺,⍶,⍵}/⍵}
+  isor←{1ₓ ⍬≡[≡⍵ ⍴⍵]}  ⍝ is ⎕or of object?
+  glue←{0ₓ=⍴⍵?⍵;⍺{⍺,⍶,⍵}/⍵}
   isor ⍵?format⊂⍵;
-  1=≡,⍵?format ⍵;
+  1ₓ=≡,⍵?format ⍵;
   box ⍵  ⍝ recursive boxing of array.
 }
 
@@ -148,9 +148,9 @@ display ← {  ⍝ Boxed display of array.
     lft,(top⍪⍵⍪bot),rgt  ⍝ fully boxed array
   }
   line←{(""≡0⍴⍵)⊃" -"}
-  0=≡⍵?' '⍪(open format ⍵)⍪line ⍵;
-  1 ⍬≡[≡⍵ ⍴⍵]?'∇' 0 0 box format ⍵;
-  1=≡⍵?(deco ⍵)box open format open ⍵;
+  0ₓ=≡⍵?' '⍪(open format ⍵)⍪line ⍵;
+  1ₓ ⍬≡[≡⍵ ⍴⍵]?'∇' 0 0 box format ⍵;
+  1ₓ=≡⍵?(deco ⍵)box open format open ⍵;
   ('∊'deco ⍵)box trim format ∇¨open ⍵
 }
 
@@ -169,11 +169,11 @@ displays ← {  ⍝ Boxed display of array.
     lft←⍉'┌',(⊃lax),'└'
     lft,(top⍪w⍪bot),rgt  ⍝ Fully boxed array.
   }
-  trim←{[⍵₀ (~1 1⍷∧⌿' '=⍵₁)#⍠¯1⍵₁]}
+  trim←{[⍵₀ (~$t $t⍷∧⌿' '=⍵₁)#⍠¯1⍵₁]}
   qfmt←{[⍬⍕⍴⍺;format open ⍵]}
-  0=≡⍵?' '⍪(format ⍵)⍪(' '≡↑0⍴⍵)⊃" -";
-  1 ⍬≡[≡⍵ ⍴⍵]?'∇' 0 0 box ["─";format ⍵];
-  1=≡⍵?(deco ⍵)box open ⍵ qfmt ⍵;  ⍝ Simple array.
+  0ₓ=≡⍵?' '⍪(format ⍵)⍪(' '≡↑0⍴⍵)⊃" -";
+  1ₓ ⍬≡[≡⍵ ⍴⍵]?'∇' 0 0 box ["─";format ⍵];
+  1ₓ=≡⍵?(deco ⍵)box open ⍵ qfmt ⍵;  ⍝ Simple array.
   ('∊'deco ⍵)box trim ⍵ qfmt ∇¨open ⍵  ⍝ Nested array.
 }
 
@@ -185,15 +185,15 @@ displayr ← {  ⍝ Boxed display of array
     top←(≥⍴hrz)↑(↑ ¯1↑⍺ ⌷ "─⊖",⊂⍬⍕¯1↑⍺₁),hrz
     bot←⍴top ↑ ↑2↓⍺ , hrz
     rgt←"┐│",vrt,'┘'  ⍝ right side with corners
-    lax←(↑¨ ¯1↓3↓⍺ ⌷¨ -1⌈≤⍴⍺₁ ↑ ⊂"│⌽" ,¨ (⊂⍬↣⍕)¨¯1↓0,⍺₁),¨⊂vrt
+    lax←(↑¨ ¯1↓3↓⍺ ⌷¨ -1⌈≤⍴⍺₁ ↑ ⊂"│⌽" ,¨ (⊂⍬↣⍕)¨¯1↓0ₓ,⍺₁),¨⊂vrt
     lax←⊂≥⍴vrt ↑¨ lax~¨⊂" " ,¨ '│'  ⍝ pad and trim
     lft←⍉'┌',(⊃lax),'└'
     lft,(top⍪⍵⍪bot),rgt  ⍝ fully boxed array
   }
-  deco←{⍺←type open ⍵ ⋄ ⍴⍴⍵ , ⊂0+⍴⍵ , ⍺ , axes ⍵}
-  0=≡⍵?' '⍪(open format ⍵)⍪(' '=↑0⍴⍵)⊃" -";
-  1 ⍬≡[≡⍵ ⍴⍵]?["" [0 0] '∇' 0 0] box format ⍵;
-  1=≡⍵?(deco ⍵)box open' ',format open ⍵;
+  deco←{⍺←type open ⍵ ⋄ ⍴⍴⍵ , ⊂0ₓ+⍴⍵ , ⍺ , axes ⍵}
+  0ₓ=≡⍵?' '⍪(open format ⍵)⍪(' '=↑0⍴⍵)⊃" -";
+  1ₓ ⍬≡[≡⍵ ⍴⍵]?["" [0 0]ₓ '∇' 0 0] box format ⍵;
+  1ₓ=≡⍵?(deco ⍵)box open' ',format open ⍵;
   (⊂⍬⍕≡⍵ deco ⍵)box trim' ',format ∇¨open ⍵
 }
 
@@ -211,9 +211,9 @@ fuzzy ← {a←lcase ⍺ ⋄ (↑⍋a↣dist∘lcase¨⍵)⊃⍵}
 ⍝ From http://dfns.dyalog.com/n_dsp.htm
 
 dsp ← {  ⍝ Reduced version of disp.
-  (1=≡,⍵)∨0∊⍴⍵?format ⍵;
+  (1ₓ=≡,⍵)∨0ₓ∊⍴⍵?format ⍵;
   ⍺←1 ⋄ top←'─'⍪⍣⍺  ⍝ top '─' bar if ⍺
-  1≥⍴⍴⍵?{  ⍝ vector or unit:
+  1ₓ≥⍴⍴⍵?{  ⍝ vector or unit:
     bars←{⍪(⌊/≢¨[⍺ ⍵])#'│'}/↕⍵,0
     join←{⊃,/(⌈/≢¨⍵)↑¨⍵}
     0 ¯1↓join top¨join¨↓⍉[⍵⋄bars]
@@ -238,7 +238,7 @@ Rgt ← {⊂2↑⍵ , 2↓¯1↓⍵ , ↑⌽⍵}  ⍝ tape-head moves right 1 it
 ⍝ From http://dfns.dyalog.com/c_enlist.htm
 
 enlist ← {  ⍝ List ⍺-leaves of nested array.
-  ⍺←0  ⍝ default: list 0-leaves.
+  ⍺←0ₓ  ⍝ default: list 0-leaves.
   ⍺≥≤≡⍵?,⍵;  ⍝ all shallow leaves: finished.
   1↓,/[⊂↑↑⍵],⍺∇¨,⍵
 }
@@ -248,7 +248,7 @@ enlist ← {  ⍝ List ⍺-leaves of nested array.
 from ← {  ⍝ Select (1↓⍴⍵)-cells from array ⍵.
   ~(≢⍺)≡≢⍴⍵?"error";  ⍝ check index length.
   indx←⍺
-  axes←+\0,¯1↓{↑⍴⍴⍵}¨⍺
+  axes←+\0ₓ,¯1↓{↑⍴⍴⍵}¨⍺
   {
     [indx axis]←⍺  ⍝ index and axis for selection.
     indx≡,⊂⍬?⍵;  ⍝ skip: select all items.
@@ -305,14 +305,14 @@ listRmDups ← {  ⍝ remove adjacent duplicates.
 ⍝ From http://dfns.dyalog.com/c_match.htm
 
 match ← {  ⍝ Wildcard match.
-  [p x]←{[⍵ '*']}⍣ 1=≡,⍺ ,⍺  ⍝ pattern and wildcard.
+  [p x]←{[⍵ '*']}⍣ 1ₓ=≡,⍺ ,⍺  ⍝ pattern and wildcard.
   v←1↓¨{(x↣≡¨⍵)⊂⍵}[x],p
   h←⊃v⍷¨⊂⍵
-  r←0,¯1↓,⊃⍴¨v
+  r←0ₓ,¯1↓,⊃⍴¨v
   sl←{  ⍝ array shifted left.
     a←¯1↓⍴⍵  ⍝ leading axes.
     x←⌈/⍺  ⍝ maximum shift.
-    p←⍵,(a,x)⍴0  ⍝ 0-padded on right.
+    p←⍵,(a,x)⍴$f  ⍝ 0-padded on right.
     s←⍉a⍴⍺  ⍝ sub-array of vector rotations.
     (- 0×a , x)↓s⌽p  ⍝ shifted array.
   }  ⍝ :: r ∇ a → a
@@ -332,7 +332,7 @@ showmatch ← {marks←[(⍺ match ⍵)]⌷" ¯" ⋄ ,⍠ ⍳⍴⍴⍵ ⍵ {[⍺
 nlines ← {  ⍝ Number of display lines for simple array.
   {
     (×/⍵)+{  ⍝ # of lines of real data +
-      +/+\0⌈⍵-1,¯1↓⍵  ⍝ # of blank lines separating different planes
+      +/+\0ₓ⌈⍵-1ₓ,¯1↓⍵  ⍝ # of blank lines separating different planes
     }×\¯1↓⍵  ⍝ of the array
   }¯1↓⍴⍵  ⍝ last axis affects only width of display.
 }
@@ -340,7 +340,7 @@ nlines ← {  ⍝ Number of display lines for simple array.
 ⍝ From http://dfns.dyalog.com/s_perv.htm
 
 perv ← {  ⍝ Pervasion
-  1=≡[⍺ ⍵ ⍵]?⍺ ⍶ ⍵;
+  1ₓ=≡[⍺ ⍵ ⍵]?⍺ ⍶ ⍵;
   ⍺ ∇¨ ⍵  ⍝ (⍺ or) ⍵ deeper: recursive traversal.
 }
 
@@ -348,7 +348,7 @@ perv ← {  ⍝ Pervasion
 
 pmat ← {  ⍝ Permutation matrix of ⍳⍵.
   {  ⍝ perms of ⍳⍵:
-    1≥⍴⍵?⊃,↓⍵;⊃⍪/⍵,↢∇¨⍵↣~¨,¨⍵
+    1ₓ≥⍴⍵?⊃,↓⍵;⊃⍪/⍵,↢∇¨⍵↣~¨,¨⍵
   }⍳⍵  ⍝ permutations of identity perm.
 }
 
@@ -359,7 +359,7 @@ pred ← {⊃⍶/¨(⍺#≥⍳⍴⍺)⊆⍵}  ⍝ Partitioned reduction.
 ⍝ From http://dfns.dyalog.com/c_rows.htm
 
 rows ← {  ⍝ Operand function applied to argument rows.
-  1<≡⍵?∇¨⍵;  ⍝ nested: item-wise application
+  1ₓ<≡⍵?∇¨⍵;  ⍝ nested: item-wise application
   ⍶⍤1 ⍵
 }
 
@@ -373,9 +373,9 @@ sam ← {  ⍝ Select and modify.
 ⍝ From http://dfns.dyalog.com/c_saw.htm
 
 saw ← {  ⍝ Function operand applied Simple-Array-Wise.
-  2≥≡[⍺ ⍵ ⍵]?⍺ ⍶ ⍵;
-  1≥≡⍵?⍺ ∇¨ ⊂⍵;  ⍝ ⍵ simple: traverse ⍺.
-  2≥≡[⍺ 1]?(⍺ ∇)¨⍵;  ⍝ ⍺ simple: traverse ⍵.
+  2ₓ≥≡[⍺ ⍵ ⍵]?⍺ ⍶ ⍵;
+  1ₓ≥≡⍵?⍺ ∇¨ ⊂⍵;  ⍝ ⍵ simple: traverse ⍺.
+  2ₓ≥≡[⍺ 1]?(⍺ ∇)¨⍵;  ⍝ ⍺ simple: traverse ⍵.
   ⍺ ∇¨ ⍵  ⍝ Both nested: traverse both.
 }
 
@@ -383,20 +383,20 @@ saw ← {  ⍝ Function operand applied Simple-Array-Wise.
 
 mscan ← {  ⍝ Minus scan.
   ⍺←¯1  ⍝ ⍺ is axis (default last).
-  +\⍠⍺ ⍵×⍠⍺(⍺⊃⍴⍵)⍴1,-1
+  +\⍠⍺ ⍵×⍠⍺(⍺⊃⍴⍵)⍴[1 ¯1]ₓ
 }
 
 ⍝ From http://dfns.dyalog.com/c_dscan.htm
 
 dscan ← {  ⍝ Divide scan
   ⍺←¯1  ⍝ ⍺ is axis (default last).
-  ×\⍠⍺ ⍵*⍠⍺(⍺⊃⍴⍵)⍴1,-1
+  ×\⍠⍺ ⍵*⍠⍺(⍺⊃⍴⍵)⍴[1 ¯1]ₓ
 }
 
 ⍝ From http://dfns.dyalog.com/c_ascan.htm
 
 ascan ← {  ⍝ Associative scan.
-  2>0⊥⍴⍵?⍵;  ⍝ few items: done.
+  2ₓ>0ₓ⊥⍴⍵?⍵;  ⍝ few items: done.
   lane←⍶{⌽⍶{[(↑⍵)⍶⍺],⍵}/⌽[⊂↑⍵],1↓⍵}  ⍝ one lane: builds the results newest first, then reverses them.
   lane⍤1 ⍵
 }
@@ -418,8 +418,8 @@ shannon ← {-+/(2↣⍟×⊣)¨(≢⊢ ⌸÷≢)⍵}  ⍝ Shannon entropy of me
 
 ⍝ From http://dfns.dyalog.com/c_subvec.htm
 
-subvec ← {0∊⍴⍺?1;  ⍝ Is ⍺ a subvector of ⍵?
-  0∊⍴⍵?0;  ⍝ null ⍵: failure.
+subvec ← {0ₓ∊⍴⍺?$t;  ⍝ Is ⍺ a subvector of ⍵?
+  0ₓ∊⍴⍵?$f;  ⍝ null ⍵: failure.
   (1↓⍺)∇(≥⍵⍳1↑⍺)↓⍵  ⍝ otherwise, check remaining items.
 }
 
@@ -427,11 +427,11 @@ subvec ← {0∊⍴⍺?1;  ⍝ Is ⍺ a subvector of ⍵?
 
 subs ← {  ⍝ Vector substitution.
   [fs ts]←≢¨[fm to]←⍺  ⍝ old and new vectors and sizes
-  1≡≡⍺?to@[fm=] ⍵;  ⍝ special case: atom subs
-  0=⍴⍴⍵?↑(⍵≡fm)⌽[⍵ ⊂to];
-  lead←fs↑1  ⍝ leading mask
+  1ₓ≡≡⍺?to@[fm=] ⍵;  ⍝ special case: atom subs
+  0ₓ=⍴⍴⍵?↑(⍵≡fm)⌽[⍵ ⊂to];
+  lead←fs↑$t  ⍝ leading mask
   (fm⍷⍵){  ⍝ hits mask
-    ~1∊⍺?⍵;  ⍝ early out if no match
+    ~$t∊⍺?⍵;  ⍝ early out if no match
     ts↓,/{to,fs↓⍵}¨(lead,⍺)⊂fm,⍵
   }⍤1 ⍵  ⍝ apply to vectors
 }