runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/sort.js

@@ -0,0 +1,195 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "sort",
+    "category": "array/sorting_sets",
+    "keywords": [
+        "sort",
+        "ascending",
+        "descending",
+        "indices",
+        "comparisonmethod",
+        "gpu"
+    ],
+    "summary": "Sort scalars, vectors, matrices, or N-D tensors along a dimension, with optional index outputs.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/sort.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Uses the provider `sort_dim` hook when available; otherwise tensors are gathered and sorted on the host."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::sorting_sets::sort::tests",
+        "integration": "builtins::array::sorting_sets::sort::tests::sort_gpu_round_trip"
+    },
+    "description": "`sort` orders the elements of its input along a chosen dimension. By default, it sorts ascending along the first non-singleton dimension and can also return the permutation indices that achieve the ordering.",
+    "behaviors": [
+        "Scalars remain unchanged; vectors are reordered into ascending or descending order.",
+        "For matrices and higher-dimensional tensors, the sort operates along a specified dimension (default: first non-singleton). All other dimensions remain untouched.",
+        "`[B, I] = sort(A, ...)` returns both the sorted values `B` and the permutation indices `I`, using MATLAB's one-based indexing.",
+        "Direction arguments accept `'ascend'` (default) or `'descend'`.",
+        "Name-value pairs support `'ComparisonMethod'` with values `'auto'`, `'real'`, or `'abs'`. The `'abs'` option sorts by absolute value while breaking ties using the signed value.",
+        "For complex inputs, the default `'ComparisonMethod'='auto'` behaves like `'abs'` (magnitude ordering) and `'real'` compares the real component first with the imaginary component used for tie-breaking.",
+        "NaN values are treated as missing: they appear at the end for ascending sorts and at the beginning for descending sorts (matching MATLAB's `'MissingPlacement','auto'` behaviour for doubles).",
+        "Dimensions greater than `ndims(A)` are treated as singleton dimensions (size 1) and therefore leave `A` unchanged while returning index values of `1`."
+    ],
+    "examples": [
+        {
+            "description": "Sorting a column vector in ascending order",
+            "input": "A = [3; 1; 2];\nB = sort(A)",
+            "output": "B =\n     1\n     2\n     3"
+        },
+        {
+            "description": "Sorting rows by specifying the dimension",
+            "input": "A = [1 4 2; 3 2 5];\nB = sort(A, 2)",
+            "output": "B =\n     1     2     4\n     2     3     5"
+        },
+        {
+            "description": "Sorting values in descending order",
+            "input": "A = [10 4 7 9];\nB = sort(A, 'descend')",
+            "output": "B =\n    10     9     7     4"
+        },
+        {
+            "description": "Retrieving permutation indices alongside the sorted values",
+            "input": "A = [4 1 9 2];\n[B, I] = sort(A)",
+            "output": "B =\n     1     2     4     9\nI =\n     2     4     1     3"
+        },
+        {
+            "description": "Sorting by absolute value using `ComparisonMethod`",
+            "input": "A = [-8 -1 3 -2];\nB = sort(A, 'ComparisonMethod', 'abs')",
+            "output": "B =\n    -1    -2     3    -8"
+        },
+        {
+            "description": "Sorting tensors containing NaN values",
+            "input": "A = [NaN 4 1 2];\n[B, I] = sort(A)",
+            "output": "B =\n     1     2     4   NaN\nI =\n     3     4     2     1"
+        },
+        {
+            "description": "Sorting GPU tensors with automatic host fallback",
+            "input": "G = gpuArray(randn(5, 1));\n[B, I] = sort(G, 'descend')"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Can `sort` return both values and indices?",
+            "answer": "Yes. Use `[B, I] = sort(A, ...)` to receive the permutation indices alongside the sorted values."
+        },
+        {
+            "question": "How are NaN values handled?",
+            "answer": "NaN values are considered missing. They appear last for ascending sorts and first for descending sorts, matching MATLAB's `'MissingPlacement','auto'` default for doubles."
+        },
+        {
+            "question": "What happens when I sort along a dimension that does not exist?",
+            "answer": "`sort(A, dim)` treats dimensions beyond `ndims(A)` as singleton dimensions (size 1). The data remains unchanged and the index output is filled with ones."
+        },
+        {
+            "question": "Does `sort` support name-value arguments?",
+            "answer": "Yes. `'ComparisonMethod'` accepts `'auto'`, `'real'`, or `'abs'`. Other name-value pairs such as `'MissingPlacement'` are currently not supported and raise an error."
+        },
+        {
+            "question": "Are GPU tensors sorted in-place?",
+            "answer": "Not yet. `sort` is a sink builtin that gathers GPU tensors to host memory when no GPU sort kernel is available. Providers can implement specialised hooks in the future."
+        },
+        {
+            "question": "Does `sort` preserve the shape of the input?",
+            "answer": "Yes. The output is the same size as the input tensor. Only values along the selected dimension are reordered."
+        },
+        {
+            "question": "What numeric type do the index outputs use?",
+            "answer": "Permutation indices are returned as double-precision tensors (or scalars) using MATLAB's one-based indexing."
+        },
+        {
+            "question": "Is the sorting stable?",
+            "answer": "Yes. Equal elements (including ties when sorting by absolute value) preserve their original order."
+        },
+        {
+            "question": "How does `ComparisonMethod` behave with real inputs?",
+            "answer": "`'auto'` and `'real'` behave identically. `'abs'` sorts by absolute value and uses the signed value to break ties so that results match MATLAB."
+        },
+        {
+            "question": "How does `ComparisonMethod` behave with complex inputs?",
+            "answer": "`'auto'` (the default) and `'abs'` order values by magnitude. `'real'` compares the real component first and falls back to the imaginary component to break ties while preserving stability."
+        },
+        {
+            "question": "Do logical or scalar inputs work?",
+            "answer": "Yes. Logical inputs are promoted to double precision automatically. Scalars are returned unchanged with an index output of `1` when requested."
+        }
+    ],
+    "links": [
+        {
+            "label": "sortrows",
+            "url": "./sortrows"
+        },
+        {
+            "label": "unique",
+            "url": "./unique"
+        },
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "permute",
+            "url": "./permute"
+        },
+        {
+            "label": "argsort",
+            "url": "./argsort"
+        },
+        {
+            "label": "intersect",
+            "url": "./intersect"
+        },
+        {
+            "label": "ismember",
+            "url": "./ismember"
+        },
+        {
+            "label": "issorted",
+            "url": "./issorted"
+        },
+        {
+            "label": "setdiff",
+            "url": "./setdiff"
+        },
+        {
+            "label": "union",
+            "url": "./union"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/sorting_sets/sort.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/sorting_sets/sort.rs"
+    },
+    "gpu_behavior": [
+        "`sort` is registered as a sink builtin. When tensors reside on a GPU without a specialised sort kernel, RunMat gathers them to host memory, performs the sort, and returns host-resident outputs.",
+        "Providers may implement a future `sort_dim` hook to keep data on the GPU. Until then, all providers fall back to the host path automatically.",
+        "The returned index tensor is always host-resident double precision."
+    ],
+    "key": "sort",
+    "slug": "sort",
+    "categoryPath": [
+        "array",
+        "sorting_sets"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=sort.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sort.js","sourceRoot":"","sources":["../../../src/generated/builtins/sort.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,oBAAoB;IAChC,UAAU,EAAE;QACV,MAAM;QACN,WAAW;QACX,YAAY;QACZ,SAAS;QACT,kBAAkB;QAClB,KAAK;KACN;IACD,SAAS,EAAE,iGAAiG;IAC5G,YAAY,EAAE;QACZ,qDAAqD;KACtD;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,0GAA0G;KACpH;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,4CAA4C;QACpD,aAAa,EAAE,iEAAiE;KACjF;IACD,aAAa,EAAE,iNAAiN;IAChO,WAAW,EAAE;QACX,qFAAqF;QACrF,mKAAmK;QACnK,gIAAgI;QAChI,iEAAiE;QACjE,kLAAkL;QAClL,0MAA0M;QAC1M,gMAAgM;QAChM,wJAAwJ;KACzJ;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,6BAA6B;YACtC,QAAQ,EAAE,6BAA6B;SACxC;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,qCAAqC;YAC9C,QAAQ,EAAE,6CAA6C;SACxD;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,yCAAyC;YAClD,QAAQ,EAAE,+BAA+B;SAC1C;QACD;YACE,aAAa,EAAE,4DAA4D;YAC3E,OAAO,EAAE,kCAAkC;YAC3C,QAAQ,EAAE,8DAA8D;SACzE;QACD;YACE,aAAa,EAAE,oDAAoD;YACnE,OAAO,EAAE,2DAA2D;YACpE,QAAQ,EAAE,+BAA+B;SAC1C;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,oCAAoC;YAC7C,QAAQ,EAAE,8DAA8D;SACzE;QACD;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,yDAAyD;SACnE;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,kGAAkG;SAC7G;QACD;YACE,UAAU,EAAE,6BAA6B;YACzC,QAAQ,EAAE,4KAA4K;SACvL;QACD;YACE,UAAU,EAAE,iEAAiE;YAC7E,QAAQ,EAAE,2JAA2J;SACtK;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,uKAAuK;SAClL;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,0KAA0K;SACrL;QACD;YACE,UAAU,EAAE,8CAA8C;YAC1D,QAAQ,EAAE,+GAA+G;SAC1H;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,8GAA8G;SACzH;QACD;YACE,UAAU,EAAE,wBAAwB;YACpC,QAAQ,EAAE,oGAAoG;SAC/G;QACD;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,iJAAiJ;SAC5J;QACD;YACE,UAAU,EAAE,yDAAyD;YACrE,QAAQ,EAAE,8LAA8L;SACzM;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,gJAAgJ;SAC3J;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;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,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,cAAc,EAAE;QACd,mMAAmM;QACnM,+IAA+I;QAC/I,qEAAqE;KACtE;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,cAAc,EAAE;QACd,OAAO;QACP,cAAc;KACf;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/sortrows.js

@@ -0,0 +1,204 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "sortrows",
+    "category": "array/sorting_sets",
+    "keywords": [
+        "sortrows",
+        "row sort",
+        "lexicographic",
+        "gpu"
+    ],
+    "summary": "Sort matrix rows lexicographically with optional column and direction control.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/sortrows.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Falls back to host memory when providers do not expose a dedicated row sort kernel."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::sorting_sets::sortrows::tests",
+        "integration": "builtins::array::sorting_sets::sortrows::tests::sortrows_gpu_roundtrip"
+    },
+    "description": "`sortrows` reorders the rows of a matrix (or character array) so they appear in lexicographic order. You can control which columns participate in the comparison and whether each column uses ascending or descending order.",
+    "behaviors": [
+        "`sortrows(A)` sorts by column `1`, then column `2`, and so on, all in ascending order.",
+        "`sortrows(A, C)` treats the vector `C` as the column order. Positive entries sort ascending; negative entries sort descending.",
+        "`sortrows(A, 'descend')` sorts all columns in descending order. Combine this with a column vector to mix directions.",
+        "`[B, I] = sortrows(A, ...)` also returns `I`, the 1-based row permutation indices.",
+        "`sortrows` is stable: rows that compare equal keep their original order.",
+        "For complex inputs, `'ComparisonMethod'` accepts `'auto'`, `'real'`, or `'abs'`, matching MATLAB semantics.",
+        "NaN handling mirrors MATLAB: in ascending sorts rows containing NaN values move to the end; in descending sorts they move to the beginning.",
+        "`'MissingPlacement'` lets you choose whether NaN (and other missing) rows appear `'first'`, `'last'`, or follow MATLAB's `'auto'` default.",
+        "Character arrays are sorted lexicographically using their character codes."
+    ],
+    "examples": [
+        {
+            "description": "Sorting rows of a matrix in ascending order",
+            "input": "A = [3 2; 1 4; 2 1];\nB = sortrows(A)",
+            "output": "B =\n     1     4\n     2     1\n     3     2"
+        },
+        {
+            "description": "Sorting by a custom column order",
+            "input": "A = [1 4 2; 3 2 5; 3 2 1];\nB = sortrows(A, [2 3 1])",
+            "output": "B =\n     3     2     1\n     3     2     5\n     1     4     2"
+        },
+        {
+            "description": "Sorting rows in descending order",
+            "input": "A = [2 8; 4 1; 3 5];\nB = sortrows(A, 'descend')",
+            "output": "B =\n     4     1\n     3     5\n     2     8"
+        },
+        {
+            "description": "Mixing ascending and descending directions",
+            "input": "A = [1 7 3; 1 2 9; 1 2 3];\nB = sortrows(A, [1 -2 3])",
+            "output": "B =\n     1     7     3\n     1     2     3\n     1     2     9"
+        },
+        {
+            "description": "Sorting rows of a character array",
+            "input": "names = ['bob '; 'al  '; 'ally'];\nsorted = sortrows(names)",
+            "output": "sorted =\nal\nally\nbob"
+        },
+        {
+            "description": "Sorting rows of complex data by magnitude",
+            "input": "Z = [3+4i, 3; 1+2i, 4];\nB = sortrows(Z, 'ComparisonMethod', 'abs')",
+            "output": "B =\n    1.0000 + 2.0000i    4.0000\n    3.0000 + 4.0000i    3.0000"
+        },
+        {
+            "description": "Forcing NaN rows to the top",
+            "input": "A = [1 NaN; NaN 2];\nB = sortrows(A, 'MissingPlacement', 'first')",
+            "output": "B =\n   NaN     2\n     1   NaN"
+        },
+        {
+            "description": "Sorting GPU-resident data with automatic host fallback",
+            "input": "G = gpuArray([3 1; 2 4; 1 2]);\n[B, I] = sortrows(G)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Can I request the permutation indices?",
+            "answer": "Yes. Call `[B, I] = sortrows(A, ...)` to receive the 1-based row permutation indices in `I`."
+        },
+        {
+            "question": "How do I sort specific columns?",
+            "answer": "Provide a column vector, e.g. `sortrows(A, [2 -3])` sorts by column `2` ascending and column `3` descending."
+        },
+        {
+            "question": "What happens when rows contain NaN values?",
+            "answer": "Rows containing NaNs move to the bottom for ascending sorts and to the top for descending sorts when `'MissingPlacement'` is left at its `'auto'` default, matching MATLAB."
+        },
+        {
+            "question": "How can I force NaNs or missing values to the top or bottom?",
+            "answer": "Use the name-value pair `'MissingPlacement','first'` to place missing rows before finite ones, or `'MissingPlacement','last'` to move them to the end regardless of direction."
+        },
+        {
+            "question": "Does `sortrows` work with complex numbers?",
+            "answer": "Yes. Use `'ComparisonMethod','real'` to sort by the real component or `'abs'` to sort by magnitude (the default behaviour matches MATLAB's `'auto'` rules)."
+        },
+        {
+            "question": "Can I combine a direction string with a column vector?",
+            "answer": "Yes. `sortrows(A, [1 3], 'descend')` applies descending order to both columns after applying the specified column order."
+        },
+        {
+            "question": "Is the operation stable?",
+            "answer": "Yes. Rows that compare equal remain in their original order."
+        },
+        {
+            "question": "Does `sortrows` mutate its input?",
+            "answer": "No. It returns a sorted copy of the input. GPU inputs are gathered to host memory when required."
+        },
+        {
+            "question": "Are string arrays supported?",
+            "answer": "String arrays are not yet supported. Convert them to character matrices or use tables before sorting."
+        },
+        {
+            "question": "What does sortrows do in MATLAB?",
+            "answer": "`sortrows(A)` sorts the rows of matrix `A` in ascending order based on the elements in the first column. Rows with equal first-column values are sorted by subsequent columns."
+        },
+        {
+            "question": "How do I sort by a specific column in MATLAB?",
+            "answer": "Use `sortrows(A, col)` where `col` is the column index. Use negative values for descending order, e.g., `sortrows(A, -2)` sorts by the second column in descending order."
+        },
+        {
+            "question": "Is sortrows a stable sort?",
+            "answer": "Yes. `sortrows` uses a stable sorting algorithm, meaning rows with equal sort keys retain their original relative order."
+        }
+    ],
+    "links": [
+        {
+            "label": "sort",
+            "url": "./sort"
+        },
+        {
+            "label": "unique",
+            "url": "./unique"
+        },
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "permute",
+            "url": "./permute"
+        },
+        {
+            "label": "argsort",
+            "url": "./argsort"
+        },
+        {
+            "label": "intersect",
+            "url": "./intersect"
+        },
+        {
+            "label": "ismember",
+            "url": "./ismember"
+        },
+        {
+            "label": "issorted",
+            "url": "./issorted"
+        },
+        {
+            "label": "setdiff",
+            "url": "./setdiff"
+        },
+        {
+            "label": "union",
+            "url": "./union"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/sorting_sets/sortrows.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/sorting_sets/sortrows.rs"
+    },
+    "gpu_behavior": [
+        "`sortrows` is registered as a sink builtin. When the input tensor already lives on the GPU and the active provider exposes a `sortrows` hook, the runtime delegates to that hook; the current provider contract returns host buffers, so the sorted rows and permutation indices are materialised on the CPU before being returned.",
+        "When the provider lacks the hook—or cannot honour a specific combination of options such as `'MissingPlacement','first'` or `'MissingPlacement','last'`—RunMat gathers the tensor and performs the sort on the host while preserving MATLAB semantics.",
+        "Name-value options that the provider does not advertize fall back automatically; callers do not need to special-case GPU vs CPU execution.",
+        "The permutation indices are emitted as double-precision column vectors so they can be reused directly for MATLAB-style indexing."
+    ],
+    "key": "sortrows",
+    "slug": "sortrows",
+    "categoryPath": [
+        "array",
+        "sorting_sets"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=sortrows.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sortrows.js","sourceRoot":"","sources":["../../../src/generated/builtins/sortrows.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,oBAAoB;IAChC,UAAU,EAAE;QACV,UAAU;QACV,UAAU;QACV,eAAe;QACf,KAAK;KACN;IACD,SAAS,EAAE,gFAAgF;IAC3F,YAAY,EAAE;QACZ,yDAAyD;KAC1D;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,qFAAqF;KAC/F;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,gDAAgD;QACxD,aAAa,EAAE,wEAAwE;KACxF;IACD,aAAa,EAAE,8NAA8N;IAC7O,WAAW,EAAE;QACX,wFAAwF;QACxF,gIAAgI;QAChI,sHAAsH;QACtH,oFAAoF;QACpF,0EAA0E;QAC1E,6GAA6G;QAC7G,6IAA6I;QAC7I,4IAA4I;QAC5I,4EAA4E;KAC7E;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,6CAA6C;YAC5D,OAAO,EAAE,uCAAuC;YAChD,QAAQ,EAAE,+CAA+C;SAC1D;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,sDAAsD;YAC/D,QAAQ,EAAE,iEAAiE;SAC5E;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,kDAAkD;YAC3D,QAAQ,EAAE,+CAA+C;SAC1D;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,uDAAuD;YAChE,QAAQ,EAAE,iEAAiE;SAC5E;QACD;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,6DAA6D;YACtE,QAAQ,EAAE,yBAAyB;SACpC;QACD;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,qEAAqE;YAC9E,QAAQ,EAAE,qEAAqE;SAChF;QACD;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,mEAAmE;YAC5E,QAAQ,EAAE,iCAAiC;SAC5C;QACD;YACE,aAAa,EAAE,wDAAwD;YACvE,OAAO,EAAE,sDAAsD;SAChE;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,8FAA8F;SACzG;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,8GAA8G;SACzH;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,6KAA6K;SACxL;QACD;YACE,UAAU,EAAE,8DAA8D;YAC1E,QAAQ,EAAE,gLAAgL;SAC3L;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,6JAA6J;SACxK;QACD;YACE,UAAU,EAAE,wDAAwD;YACpE,QAAQ,EAAE,0HAA0H;SACrI;QACD;YACE,UAAU,EAAE,0BAA0B;YACtC,QAAQ,EAAE,8DAA8D;SACzE;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,kGAAkG;SAC7G;QACD;YACE,UAAU,EAAE,8BAA8B;YAC1C,QAAQ,EAAE,uGAAuG;SAClH;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,gLAAgL;SAC3L;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,2KAA2K;SACtL;QACD;YACE,UAAU,EAAE,4BAA4B;YACxC,QAAQ,EAAE,0HAA0H;SACrI;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;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,qEAAqE;QAC9E,KAAK,EAAE,kHAAkH;KAC1H;IACD,cAAc,EAAE;QACd,qUAAqU;QACrU,wPAAwP;QACxP,4IAA4I;QAC5I,kIAAkI;KACnI;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,cAAc,EAAE;QACd,OAAO;QACP,cAAc;KACf;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/split.js

@@ -0,0 +1,178 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "split",
+    "category": "strings/transform",
+    "keywords": [
+        "split",
+        "string split",
+        "text split",
+        "delimiters",
+        "collapse delimiters",
+        "include delimiters"
+    ],
+    "summary": "Split strings, character arrays, and cell arrays into substrings using delimiters.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/split.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Executes on the CPU; GPU-resident arguments are gathered to host memory prior to splitting."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::transform::split::tests",
+        "integration": "builtins::strings::transform::split::tests::split_cell_array_mixed_inputs"
+    },
+    "description": "`split(text)` breaks text into substrings separated by delimiters. The input can be a string scalar, string array, character array, or a cell array of character vectors—`split` mirrors MATLAB behaviour across each of these representations. When you omit the delimiter argument, `split` collapses whitespace runs and returns the remaining tokens as a string array.",
+    "behaviors": [
+        "The default delimiter is whitespace (`isspace`), and consecutive whitespace is treated as a single separator (equivalent to `'CollapseDelimiters', true`).",
+        "When you supply explicit delimiters, they can be a string scalar, string array, character array (rows), or a cell array of character vectors. Delimiters are matched left to right and the longest delimiter wins when several candidates match at the same position.",
+        "`'CollapseDelimiters'` controls whether consecutive delimiters generate empty substrings. The default is `false` when you specify explicit delimiters and `true` when you rely on the whitespace default.",
+        "`'IncludeDelimiters'` inserts the matched delimiters as separate elements in the output string array.",
+        "Outputs are string arrays. For scalar inputs, the result is a row vector. For string/character arrays, the first dimension matches the number of rows in the input and additional columns are appended to accommodate the longest token list. Missing values are padded with `<missing>`.",
+        "Missing string scalars propagate unchanged."
+    ],
+    "examples": [
+        {
+            "description": "Split A String On Whitespace",
+            "input": "txt = \"RunMat Accelerate Planner\";\npieces = split(txt)",
+            "output": "pieces = 1×3 string\n    \"RunMat\"    \"Accelerate\"    \"Planner\""
+        },
+        {
+            "description": "Split A String Using A Custom Delimiter",
+            "input": "csv = \"alpha,beta,gamma\";\ntokens = split(csv, \",\")",
+            "output": "tokens = 1×3 string\n    \"alpha\"    \"beta\"    \"gamma\""
+        },
+        {
+            "description": "Include Delimiters In The Output",
+            "input": "expr = \"A+B-C\";\nsegments = split(expr, [\"+\", \"-\"], \"IncludeDelimiters\", true)",
+            "output": "segments = 1×5 string\n    \"A\"    \"+\"    \"B\"    \"-\"    \"C\""
+        },
+        {
+            "description": "Preserve Empty Segments When CollapseDelimiters Is False",
+            "input": "values = \"one,,three,\";\nparts = split(values, \",\", \"CollapseDelimiters\", false)",
+            "output": "parts = 1×4 string\n    \"one\"    \"\"    \"three\"    \"\""
+        },
+        {
+            "description": "Split Each Row Of A Character Array",
+            "input": "rows = char(\"GPU Accelerate\", \"Ignition Interpreter\");\nresult = split(rows)",
+            "output": "result = 2×2 string\n    \"GPU\"          \"Accelerate\"\n    \"Ignition\"     \"Interpreter\""
+        },
+        {
+            "description": "Split Elements Of A Cell Array",
+            "input": "C = {'RunMat Snapshot'; \"Fusion Planner\"};\nout = split(C, \" \")",
+            "output": "out = 2×2 string\n    \"RunMat\"    \"Snapshot\"\n    \"Fusion\"    \"Planner\""
+        },
+        {
+            "description": "Handle Missing String Inputs",
+            "input": "names = [\"RunMat\", \"<missing>\", \"Accelerate Engine\"];\nsplit_names = split(names)",
+            "output": "split_names = 3×2 string\n    \"RunMat\"        \"<missing>\"\n    \"<missing>\"     \"<missing>\"\n    \"Accelerate\"    \"Engine\""
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What delimiters does `split` use by default?",
+            "answer": "When you omit the second argument, `split` treats any Unicode whitespace as a delimiter and collapses consecutive whitespace runs so they produce a single split point."
+        },
+        {
+            "question": "How do explicit delimiters change the defaults?",
+            "answer": "Providing explicit delimiters switches the default for `'CollapseDelimiters'` to `false`, matching MATLAB. You can override that behaviour with a name-value pair."
+        },
+        {
+            "question": "What happens when `'IncludeDelimiters'` is `true`?",
+            "answer": "Matched delimiters are inserted between tokens in the output string array, preserving their original order. Tokens still expand to fill rows and columns, with missing values used for padding."
+        },
+        {
+            "question": "How is the output sized for string arrays?",
+            "answer": "The number of rows matches the input. Columns are added to accommodate the longest token list observed across all elements. Shorter rows are padded with `<missing>`."
+        },
+        {
+            "question": "How does `split` handle missing strings?",
+            "answer": "Missing string scalars propagate unchanged. When padding is required, `<missing>` is used so MATLAB and RunMat stay aligned."
+        },
+        {
+            "question": "Can I provide empty delimiters?",
+            "answer": "No. Empty delimiters are disallowed, matching MATLAB's input validation. Specify at least one character per delimiter."
+        },
+        {
+            "question": "Which argument types are accepted as delimiters?",
+            "answer": "You may pass string scalars, string arrays, character arrays (each row is a delimiter), or cell arrays containing string scalars or character vectors."
+        }
+    ],
+    "links": [
+        {
+            "label": "replace",
+            "url": "./replace"
+        },
+        {
+            "label": "lower",
+            "url": "./lower"
+        },
+        {
+            "label": "upper",
+            "url": "./upper"
+        },
+        {
+            "label": "strip",
+            "url": "./strip"
+        },
+        {
+            "label": "erase",
+            "url": "./erase"
+        },
+        {
+            "label": "eraseBetween",
+            "url": "./erasebetween"
+        },
+        {
+            "label": "extractBetween",
+            "url": "./extractbetween"
+        },
+        {
+            "label": "join",
+            "url": "./join"
+        },
+        {
+            "label": "pad",
+            "url": "./pad"
+        },
+        {
+            "label": "strcat",
+            "url": "./strcat"
+        },
+        {
+            "label": "strrep",
+            "url": "./strrep"
+        },
+        {
+            "label": "strtrim",
+            "url": "./strtrim"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/transform/split.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/transform/split.rs"
+    },
+    "gpu_residency": "String manipulation currently runs on the host. If text data lives on the GPU (for example after a gathered computation), `split` automatically fetches it. You never need to move text explicitly before calling this builtin.",
+    "gpu_behavior": [
+        "`split` executes on the CPU. When the input or delimiter arguments reside on the GPU, RunMat gathers them to host memory before performing the split so the results match MATLAB exactly. Providers do not need to implement custom kernels for this builtin today."
+    ],
+    "key": "split",
+    "slug": "split",
+    "categoryPath": [
+        "strings",
+        "transform"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=split.js.map

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

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

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

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

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

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