runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/issymmetric.js

@@ -0,0 +1,166 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "issymmetric",
+    "category": "math/linalg/structure",
+    "keywords": [
+        "issymmetric",
+        "symmetric matrix",
+        "skew-symmetric",
+        "matrix structure",
+        "gpu"
+    ],
+    "summary": "Test whether a matrix is symmetric or skew-symmetric, optionally within a tolerance.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Falls back to gathering GPU operands when providers lack a device-side symmetry predicate."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::linalg::structure::issymmetric::tests",
+        "integration": "builtins::math::linalg::structure::issymmetric::tests::issymmetric_gpu_roundtrip"
+    },
+    "description": "`issymmetric(A)` returns logical `true` when a numeric or logical matrix `A` is symmetric about its main diagonal (`A == A.'`) and `false` otherwise.",
+    "behaviors": [
+        "Works with scalars, vectors (treated as matrices), and higher-rank arrays whose trailing dimensions are singleton (MATLAB-compatible matrix semantics). An error is raised when the input has more than two non-singleton dimensions.",
+        "Non-square matrices immediately return `false`.",
+        "Logical inputs are promoted to double precision (`true → 1.0`, `false → 0.0`) before testing.",
+        "Complex inputs are compared without conjugation; use `ishermitian` for conjugate symmetry.",
+        "Floating-point tolerance can be supplied to account for numerical noise.",
+        "Pass `'skew'` to test skew-symmetry (`A == -A.'`). Diagonal entries must be zero (within the tolerance) when `skew` mode is active."
+    ],
+    "examples": [
+        {
+            "description": "Checking whether a matrix is symmetric",
+            "input": "A = [2 1 1; 1 3 4; 1 4 5];\ntf = issymmetric(A)",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "Allowing numerical noise with a tolerance",
+            "input": "A = [1 1+1e-12; 1-1e-12 1];\ntf = issymmetric(A, 1e-9)",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "Detecting a skew-symmetric matrix",
+            "input": "B = [0 -2 4; 2 0 -3; -4 3 0];\ntf = issymmetric(B, 'skew')",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "Handling non-square matrices",
+            "input": "C = [1 2 3; 4 5 6];\ntf = issymmetric(C)",
+            "output": "tf = logical\n   0"
+        },
+        {
+            "description": "Working with complex-valued matrices",
+            "input": "Z = [1+2i 3-4i; 3-4i 5+6i];\ntf = issymmetric(Z)",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "Inspecting a GPU-resident matrix",
+            "input": "G = gpuArray([0 5; 5 9]);\ntf = issymmetric(G)",
+            "output": "tf = logical\n   1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `issymmetric` accept tolerance arguments?",
+            "answer": "Yes. Pass a non-negative scalar tolerance as the second or third argument. The comparison uses an absolute tolerance on the element-wise difference (or sum for skew tests)."
+        },
+        {
+            "question": "What strings are accepted for the skew flag?",
+            "answer": "Use `'skew'` to test skew-symmetry and `'nonskew'` (or omit the flag) for the default symmetry test."
+        },
+        {
+            "question": "How are diagonal elements handled in skew mode?",
+            "answer": "Diagonal elements must be zero (within the tolerance) because a skew-symmetric matrix satisfies `A(i,i) = -A(i,i)`."
+        },
+        {
+            "question": "Are NaN values considered symmetric?",
+            "answer": "No. Any NaN encountered off or on the diagonal causes the test to return `false`, matching MATLAB behaviour."
+        },
+        {
+            "question": "Do logical matrices work?",
+            "answer": "Yes. Logical inputs are promoted to double precision and checked using the same rules as numeric matrices."
+        },
+        {
+            "question": "Does `issymmetric` conjugate complex inputs?",
+            "answer": "No. The builtin compares complex entries without conjugation. Use `ishermitian` if you need conjugate symmetry."
+        },
+        {
+            "question": "What happens with higher-dimensional arrays?",
+            "answer": "`issymmetric` raises an error when the input has more than two non-singleton dimensions. Reshape the data to a 2-D matrix before calling it."
+        },
+        {
+            "question": "Can I combine the skew flag and tolerance?",
+            "answer": "Yes. You can call `issymmetric(A, 'skew', tol)` or `issymmetric(A, tol, 'skew')`. The order of the optional arguments does not matter."
+        },
+        {
+            "question": "Is an empty matrix symmetric?",
+            "answer": "Yes. Empty square matrices (`0x0`) return logical `true`, while non-square empty matrices return `false`."
+        },
+        {
+            "question": "Does the result depend on GPU availability?",
+            "answer": "No. You receive the same logical answer regardless of whether a GPU provider is registered. Only the execution strategy changes (device-side predicate vs. host fallback)."
+        }
+    ],
+    "links": [
+        {
+            "label": "bandwidth",
+            "url": "./bandwidth"
+        },
+        {
+            "label": "chol",
+            "url": "./chol"
+        },
+        {
+            "label": "eig",
+            "url": "./eig"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "ishermitian",
+            "url": "./ishermitian"
+        },
+        {
+            "label": "symrcm",
+            "url": "./symrcm"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/linalg/structure/issymmetric.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/linalg/structure/issymmetric.rs"
+    },
+    "gpu_residency": "Manual `gpuArray` / `gather` calls are optional. When a provider implements the symmetry hook, RunMat executes the predicate in-place on the GPU and only transfers the scalar result. Otherwise the runtime gathers the tensor transparently and reuses the CPU path, preserving correctness with a minor residency cost.",
+    "gpu_behavior": [
+        "RunMat keeps GPU tensors resident whenever feasible. When the active acceleration provider exposes a symmetry predicate hook (`issymmetric`), the test runs entirely on the device and returns a host logical scalar. Providers without that hook gracefully fall back to downloading the matrix, so results remain correct even without GPU specialisation."
+    ],
+    "key": "issymmetric",
+    "slug": "issymmetric",
+    "categoryPath": [
+        "math",
+        "linalg",
+        "structure"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=issymmetric.js.map

package/dist/generated/builtins/issymmetric.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"issymmetric.js","sourceRoot":"","sources":["../../../src/generated/builtins/issymmetric.ts"],"names":[],"mappings":"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"}

package/dist/generated/builtins/isvector.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinDoc } from "../../builtins.js";
+declare const builtinDoc: BuiltinDoc;
+export default builtinDoc;
+//# sourceMappingURL=isvector.d.ts.map

package/dist/generated/builtins/isvector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isvector.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/isvector.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,UA+KjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/isvector.js

@@ -0,0 +1,180 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "isvector",
+    "category": "array/introspection",
+    "keywords": [
+        "isvector",
+        "vector detection",
+        "metadata query",
+        "gpu",
+        "logical"
+    ],
+    "summary": "Return true when an array is 1-by-N or N-by-1 (including scalars).",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Reads tensor metadata directly from GPU handles; gathers only when shape metadata is unavailable."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::introspection::isvector::tests",
+        "integration": "builtins::array::introspection::isvector::tests::isvector_gpu_tensor_uses_handle_shape"
+    },
+    "description": "`isvector(A)` returns logical `true` when the input is 1-by-`N` or `N`-by-1 (including scalars) and has at most two dimensions. The builtin mirrors MATLAB semantics across numeric arrays, logical arrays, characters, strings, cells, structs, objects, and GPU-resident tensors.",
+    "behaviors": [
+        "`isvector` is `true` for 1-by-`N` and `N`-by-1 arrays (with `N ≥ 0`), including scalars (`1×1`).",
+        "Arrays with more than two dimensions always return `false`, even when all trailing dimensions are singleton (for example, `1×1×1`).",
+        "Empty arrays follow MATLAB rules: size `0×1` or `1×0` is a vector, but size `0×3` is not.",
+        "Character arrays, string arrays, cell arrays, structs, objects, and handle objects follow the same dimension check.",
+        "GPU tensors use metadata stored in their `GpuTensorHandle`. If metadata is missing, RunMat gathers once to inspect dimensions.",
+        "Sparse matrices currently follow dense semantics; when sparse support lands, `isvector` will continue to rely on reported dimensions."
+    ],
+    "examples": [
+        {
+            "description": "Checking if a row vector input is a vector",
+            "input": "tf = isvector([1 2 3])",
+            "output": "tf = logical(1)"
+        },
+        {
+            "description": "Detecting that a matrix is not a vector",
+            "input": "tf = isvector([1 2 3; 4 5 6])",
+            "output": "tf = logical(0)"
+        },
+        {
+            "description": "Verifying that a scalar counts as a vector",
+            "input": "tf = isvector(42)",
+            "output": "tf = logical(1)"
+        },
+        {
+            "description": "Handling empty dimensions exactly like MATLAB",
+            "input": "tf_zero_col = isvector(zeros(1,0));\ntf_zero_row = isvector(zeros(0,1));\ntf_zero_by_three = isvector(zeros(0,3))",
+            "output": "tf_zero_col = logical(1)\ntf_zero_row = logical(1)\ntf_zero_by_three = logical(0)"
+        },
+        {
+            "description": "Working with character and string arrays",
+            "input": "tf_char = isvector('RunMat');\ntf_string_row = isvector([\"a\",\"b\",\"c\"])",
+            "output": "tf_char = logical(1)\ntf_string_row = logical(1)"
+        },
+        {
+            "description": "Confirming GPU tensor metadata without gathering",
+            "input": "G = gpuArray((1:5)');\ntf_gpu = isvector(G)",
+            "output": "tf_gpu = logical(1)"
+        },
+        {
+            "description": "Rejecting higher-dimensional arrays",
+            "input": "tf = isvector(ones(1,1,4))",
+            "output": "tf = logical(0)"
+        },
+        {
+            "description": "Trailing singleton dimensions are still rejected",
+            "input": "tf = isvector(ones(1,1,1))",
+            "output": "tf = logical(0)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `isvector` treat scalars as vectors?",
+            "answer": "Yes. Scalars are 1-by-1 arrays, so they are vectors."
+        },
+        {
+            "question": "How does `isvector` handle empty dimensions?",
+            "answer": "It follows MATLAB rules: size 0-by-1 or 1-by-0 is a vector, but other empty shapes such as 0-by-3 return `false`."
+        },
+        {
+            "question": "Are higher-dimensional arrays ever considered vectors?",
+            "answer": "No. Any array with more than two dimensions returns `false`, even if the trailing dimensions equal one (for example, `1×1×N`)."
+        },
+        {
+            "question": "Do character vectors and string scalars count as vectors?",
+            "answer": "Yes. Character vectors are 1-by-N arrays, and string scalars are 1-by-1 string arrays, so both return `true`."
+        },
+        {
+            "question": "What happens with GPU arrays?",
+            "answer": "RunMat reads the shape metadata from the `GpuTensorHandle`. If the provider does not populate that metadata, the runtime gathers the tensor once to inspect its dimensions."
+        },
+        {
+            "question": "Are cell arrays and structs supported?",
+            "answer": "Yes. `isvector` uses the MATLAB-visible dimensions, so any 1-by-N or N-by-1 cell/struct array returns `true`."
+        },
+        {
+            "question": "Will `isvector` launch GPU kernels?",
+            "answer": "No. The builtin is purely a metadata query and never dispatches GPU work."
+        },
+        {
+            "question": "Can I rely on `isvector` inside fused expressions?",
+            "answer": "Yes. The builtin returns a host logical scalar, so fusion planning treats it as a metadata operation."
+        },
+        {
+            "question": "Does sparse support change the semantics?",
+            "answer": "Sparse inputs will follow the same dimension check once sparse tensors are introduced; no behavioural change is expected."
+        },
+        {
+            "question": "How does `isvector` interact with `isscalar` and `ismatrix`?",
+            "answer": "`isscalar(A)` implies `isvector(A)` but not vice versa. Conversely, `ismatrix(A)` can be `true` even when `isvector(A)` is `false`."
+        }
+    ],
+    "links": [
+        {
+            "label": "isscalar",
+            "url": "./isscalar"
+        },
+        {
+            "label": "isempty",
+            "url": "./isempty"
+        },
+        {
+            "label": "length",
+            "url": "./length"
+        },
+        {
+            "label": "numel",
+            "url": "./numel"
+        },
+        {
+            "label": "size",
+            "url": "./size"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "ismatrix",
+            "url": "./ismatrix"
+        },
+        {
+            "label": "ndims",
+            "url": "./ndims"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/introspection/isvector.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/introspection/isvector.rs"
+    },
+    "gpu_residency": "`isvector` performs its checks on whatever residency the input already uses. It will happily accept a GPU tensor without the caller moving it to the CPU first, because the builtin only needs the tensor's metadata. When a provider fully populates tensor shapes (as the WGPU provider does), the runtime never downloads the data. If metadata is missing, the runtime gathers once to recover the shape and then continues on the host. Users can still call `gpuArray` for compatibility with MathWorks MATLAB, but it is not required for this builtin.",
+    "gpu_behavior": [
+        "`isvector` never launches GPU kernels. For `gpuArray` inputs the builtin first inspects the shape metadata on the `GpuTensorHandle`. If a provider omits that metadata, RunMat downloads the tensor once to obtain it and then computes the result on the host. The builtin always returns a host logical scalar, so fusion planning treats it as a metadata query instead of a device-side kernel."
+    ],
+    "key": "isvector",
+    "slug": "isvector",
+    "categoryPath": [
+        "array",
+        "introspection"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=isvector.js.map

package/dist/generated/builtins/isvector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isvector.js","sourceRoot":"","sources":["../../../src/generated/builtins/isvector.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,UAAU;QACV,kBAAkB;QAClB,gBAAgB;QAChB,KAAK;QACL,SAAS;KACV;IACD,SAAS,EAAE,oEAAoE;IAC/E,YAAY,EAAE,EAAE;IAChB,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,mGAAmG;KAC7G;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,iDAAiD;QACzD,aAAa,EAAE,wFAAwF;KACxG;IACD,aAAa,EAAE,qRAAqR;IACpS,WAAW,EAAE;QACX,kGAAkG;QAClG,qIAAqI;QACrI,2FAA2F;QAC3F,qHAAqH;QACrH,gIAAgI;QAChI,uIAAuI;KACxI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,wBAAwB;YACjC,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,+BAA+B;YACxC,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,mBAAmB;YAC5B,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,mHAAmH;YAC5H,QAAQ,EAAE,mFAAmF;SAC9F;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,8EAA8E;YACvF,QAAQ,EAAE,kDAAkD;SAC7D;QACD;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,6CAA6C;YACtD,QAAQ,EAAE,qBAAqB;SAChC;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,iBAAiB;SAC5B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,sDAAsD;SACjE;QACD;YACE,UAAU,EAAE,8CAA8C;YAC1D,QAAQ,EAAE,mHAAmH;SAC9H;QACD;YACE,UAAU,EAAE,wDAAwD;YACpE,QAAQ,EAAE,gIAAgI;SAC3I;QACD;YACE,UAAU,EAAE,2DAA2D;YACvE,QAAQ,EAAE,+GAA+G;SAC1H;QACD;YACE,UAAU,EAAE,+BAA+B;YAC3C,QAAQ,EAAE,6KAA6K;SACxL;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,+GAA+G;SAC1H;QACD;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,2EAA2E;SACtF;QACD;YACE,UAAU,EAAE,oDAAoD;YAChE,QAAQ,EAAE,uGAAuG;SAClH;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,2HAA2H;SACtI;QACD;YACE,UAAU,EAAE,8DAA8D;YAC1E,QAAQ,EAAE,qIAAqI;SAChJ;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,sEAAsE;QAC/E,KAAK,EAAE,mHAAmH;KAC3H;IACD,eAAe,EAAE,giBAAgiB;IACjjB,cAAc,EAAE;QACd,qYAAqY;KACtY;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,cAAc,EAAE;QACd,OAAO;QACP,eAAe;KAChB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/join.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinDoc } from "../../builtins.js";
+declare const builtinDoc: BuiltinDoc;
+export default builtinDoc;
+//# sourceMappingURL=join.d.ts.map

package/dist/generated/builtins/join.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/join.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,UAwLjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/join.js

@@ -0,0 +1,189 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "join",
+    "category": "strings/transform",
+    "keywords": [
+        "join",
+        "string join",
+        "concatenate strings",
+        "delimiters",
+        "cell array join",
+        "dimension join"
+    ],
+    "summary": "Combine text across a specified dimension inserting delimiters between elements.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/join.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Executes on the CPU; GPU-resident inputs and delimiters are gathered before joining to ensure MATLAB-compatible behaviour."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::transform::join::tests",
+        "integration": "builtins::strings::transform::join::tests::join_cell_array_of_char_vectors"
+    },
+    "description": "`join` concatenates text along a chosen dimension of a string array or a cell array of character vectors. It inserts delimiters between neighbouring elements and mirrors MATLAB semantics for default dimension selection, delimiter broadcasting, and handling of missing strings.",
+    "behaviors": [
+        "When you omit the dimension, `join` operates along the **last dimension whose size is not 1**. If all dimensions are singleton, it uses dimension 2.",
+        "The default delimiter is a single space character. You can pass a scalar delimiter (string or character vector) or supply a string/cell array whose shape matches the input, with the join dimension reduced by one, to customise delimiters for each gap.",
+        "Inputs may be string scalars, string arrays (including N-D), character arrays, or cell arrays of character vectors. Cell inputs return cell arrays; all other inputs return string scalars or string arrays.",
+        "If any element participating in a join is the string `<missing>`, the result for that slice is also `<missing>`, matching MATLAB’s missing propagation rules.",
+        "Joining along a dimension greater than `ndims(str)` leaves the input unchanged."
+    ],
+    "examples": [
+        {
+            "description": "Combine Strings In Each Row Of A Matrix",
+            "input": "names = [\"Carlos\" \"Sada\"; \"Ella\" \"Olsen\"; \"Diana\" \"Lee\"];\nfullNames = join(names)",
+            "output": "fullNames = 3×1 string\n    \"Carlos Sada\"\n    \"Ella Olsen\"\n    \"Diana Lee\""
+        },
+        {
+            "description": "Insert A Custom Delimiter Between Elements",
+            "input": "labels = [\"x\" \"y\" \"z\"; \"a\" \"b\" \"c\"];\njoined = join(labels, \"-\")",
+            "output": "joined = 2×1 string\n    \"x-y-z\"\n    \"a-b-c\""
+        },
+        {
+            "description": "Provide A Delimiter Array That Varies Per Row",
+            "input": "str = [\"x\" \"y\" \"z\"; \"a\" \"b\" \"c\"];\ndelims = [\" + \" \" = \"; \" - \" \" = \"];\nequations = join(str, delims)",
+            "output": "equations = 2×1 string\n    \"x + y = z\"\n    \"a - b = c\""
+        },
+        {
+            "description": "Join Along A Specific Dimension",
+            "input": "scores = [\"Alice\" \"Bob\"; \"92\" \"88\"; \"85\" \"90\"];\nbyColumn = join(scores, 1)",
+            "output": "byColumn = 1×2 string\n    \"Alice 92 85\"    \"Bob 88 90\""
+        },
+        {
+            "description": "Join A Cell Array Of Character Vectors",
+            "input": "C = {'GPU', 'Accelerate'; 'Ignition', 'Interpreter'};\nresult = join(C, \", \")",
+            "output": "result = 2×1 cell\n    {'GPU, Accelerate'}\n    {'Ignition, Interpreter'}"
+        },
+        {
+            "description": "Join Using A Dimension Argument As The Second Input",
+            "input": "words = [\"RunMat\"; \"Accelerate\"; \"Planner\"];\nsentence = join(words, 1)",
+            "output": "sentence = \"RunMat Accelerate Planner\""
+        },
+        {
+            "description": "Join Rows Of An Empty String Array",
+            "input": "emptyRows = strings(2, 0);\nout = join(emptyRows)",
+            "output": "out = 2×1 string\n    \"\"\n    \"\""
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How does `join` choose the dimension when I do not specify one?",
+            "answer": "It looks for the last dimension whose size is not 1 and joins along that axis. If every dimension has size 1, it uses dimension 2."
+        },
+        {
+            "question": "Can I use different delimiters between separate pairs of strings?",
+            "answer": "Yes. Supply a string array or a cell array of character vectors with the same size as `str`, except that the join dimension must be one element shorter. Values of size 1 in other dimensions broadcast."
+        },
+        {
+            "question": "What happens when `str` contains `<missing>`?",
+            "answer": "The result for that slice becomes `<missing>`. This matches MATLAB’s behaviour and ensures missing values propagate."
+        },
+        {
+            "question": "Can I pass GPU-resident text or delimiters?",
+            "answer": "You can; RunMat gathers them to host memory automatically before performing the join."
+        },
+        {
+            "question": "What if I request a dimension larger than `ndims(str)`?",
+            "answer": "`join` returns the original text unchanged, matching MATLAB semantics."
+        },
+        {
+            "question": "Does `join` support numeric or logical inputs?",
+            "answer": "No. Convert them to strings first (e.g., with `string` or `compose`), then call `join`."
+        },
+        {
+            "question": "How do I join every element into a single string?",
+            "answer": "Specify the dimension explicitly. For column vectors, use `join(str, 1)`; for higher dimensional arrays, choose the axis that spans the elements you want to combine."
+        },
+        {
+            "question": "Are cell array outputs returned as strings?",
+            "answer": "No. When the input is a cell array, the output is a cell array of character vectors, keeping parity with MATLAB."
+        }
+    ],
+    "links": [
+        {
+            "label": "split",
+            "url": "./split"
+        },
+        {
+            "label": "compose",
+            "url": "./compose"
+        },
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "erase",
+            "url": "./erase"
+        },
+        {
+            "label": "eraseBetween",
+            "url": "./erasebetween"
+        },
+        {
+            "label": "extractBetween",
+            "url": "./extractbetween"
+        },
+        {
+            "label": "lower",
+            "url": "./lower"
+        },
+        {
+            "label": "pad",
+            "url": "./pad"
+        },
+        {
+            "label": "replace",
+            "url": "./replace"
+        },
+        {
+            "label": "strcat",
+            "url": "./strcat"
+        },
+        {
+            "label": "strip",
+            "url": "./strip"
+        },
+        {
+            "label": "strrep",
+            "url": "./strrep"
+        },
+        {
+            "label": "strtrim",
+            "url": "./strtrim"
+        },
+        {
+            "label": "upper",
+            "url": "./upper"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/transform/join.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/transform/join.rs"
+    },
+    "gpu_residency": "No. Text manipulation currently runs on the CPU. If your text or delimiters were produced on the GPU, RunMat gathers them automatically so that you can call `join` without extra steps.",
+    "gpu_behavior": [
+        "`join` executes on the CPU. When text or delimiters reside on the GPU, RunMat gathers them to host memory before performing the concatenation, ensuring identical results to MATLAB. Providers do not need to implement custom kernels for this builtin today."
+    ],
+    "key": "join",
+    "slug": "join",
+    "categoryPath": [
+        "strings",
+        "transform"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=join.js.map

package/dist/generated/builtins/join.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.js","sourceRoot":"","sources":["../../../src/generated/builtins/join.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,MAAM;QACN,aAAa;QACb,qBAAqB;QACrB,YAAY;QACZ,iBAAiB;QACjB,gBAAgB;KACjB;IACD,SAAS,EAAE,kFAAkF;IAC7F,YAAY,EAAE;QACZ,qDAAqD;KACtD;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,4HAA4H;KACtI;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,2CAA2C;QACnD,aAAa,EAAE,4EAA4E;KAC5F;IACD,aAAa,EAAE,sRAAsR;IACrS,WAAW,EAAE;QACX,sJAAsJ;QACtJ,4PAA4P;QAC5P,8MAA8M;QAC9M,+JAA+J;QAC/J,iFAAiF;KAClF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,gGAAgG;YACzG,QAAQ,EAAE,oFAAoF;SAC/F;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,gFAAgF;YACzF,QAAQ,EAAE,mDAAmD;SAC9D;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,4HAA4H;YACrI,QAAQ,EAAE,8DAA8D;SACzE;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,yFAAyF;YAClG,QAAQ,EAAE,6DAA6D;SACxE;QACD;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,iFAAiF;YAC1F,QAAQ,EAAE,2EAA2E;SACtF;QACD;YACE,aAAa,EAAE,qDAAqD;YACpE,OAAO,EAAE,+EAA+E;YACxF,QAAQ,EAAE,0CAA0C;SACrD;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,mDAAmD;YAC5D,QAAQ,EAAE,sCAAsC;SACjD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iEAAiE;YAC7E,QAAQ,EAAE,oIAAoI;SAC/I;QACD;YACE,UAAU,EAAE,mEAAmE;YAC/E,QAAQ,EAAE,0MAA0M;SACrN;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,sHAAsH;SACjI;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,uFAAuF;SAClG;QACD;YACE,UAAU,EAAE,yDAAyD;YACrE,QAAQ,EAAE,wEAAwE;SACnF;QACD;YACE,UAAU,EAAE,gDAAgD;YAC5D,QAAQ,EAAE,yFAAyF;SACpG;QACD;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,uKAAuK;SAClL;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,kHAAkH;SAC7H;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,cAAc;YACvB,KAAK,EAAE,gBAAgB;SACxB;QACD;YACE,OAAO,EAAE,gBAAgB;YACzB,KAAK,EAAE,kBAAkB;SAC1B;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,gEAAgE;QACzE,KAAK,EAAE,6GAA6G;KACrH;IACD,eAAe,EAAE,0LAA0L;IAC3M,cAAc,EAAE;QACd,gQAAgQ;KACjQ;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,cAAc,EAAE;QACd,SAAS;QACT,WAAW;KACZ;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/jsondecode.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinDoc } from "../../builtins.js";
+declare const builtinDoc: BuiltinDoc;
+export default builtinDoc;
+//# sourceMappingURL=jsondecode.d.ts.map

package/dist/generated/builtins/jsondecode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsondecode.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/jsondecode.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,UA0JjB,CAAC;AAEF,eAAe,UAAU,CAAC"}