runmat 0.3.5 → 0.4.0

package/dist/generated/builtins/strfind.js

@@ -0,0 +1,136 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "strfind",
+    "category": "strings/search",
+    "keywords": [
+        "strfind",
+        "substring",
+        "index",
+        "positions",
+        "forcecelloutput"
+    ],
+    "summary": "Locate the starting indices of pattern matches in text inputs, returning doubles or cell arrays like MATLAB.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/strfind.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "matlab",
+        "notes": "Executes on the CPU. When inputs reside on the GPU, RunMat gathers them automatically before searching."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::search::strfind::tests",
+        "integration": "builtins::strings::search::strfind::tests::strfind_subject_cell_scalar_returns_cell"
+    },
+    "description": "`k = strfind(str, pattern)` returns the starting indices of every occurrence of `pattern` inside `str`. The builtin mirrors MATLAB semantics for character vectors, string scalars, string arrays, and cell arrays of character vectors.",
+    "behaviors": [
+        "Accepts text inputs as string scalars/arrays, character vectors/arrays, or cell arrays of character vectors. Mixed combinations are permitted.",
+        "Applies MATLAB-style implicit expansion when either argument is non-scalar.",
+        "Returns a numeric row vector when both inputs are scalar text (character vectors or string scalars) and `'ForceCellOutput'` is `false`. If either input is a cell array or the broadcasted result contains multiple elements, the output is a cell array with the broadcasted shape, and each cell contains a row vector of double indices.",
+        "Pattern matches are case-sensitive and may overlap. For example, `strfind(\"aaaa\",\"aa\")` yields `[1 2 3]`.",
+        "An empty pattern matches the boundaries between characters, producing indices `1:length(str)+1`. Missing strings (`<missing>`) never match any pattern.",
+        "Specify `'ForceCellOutput', true` to always obtain a cell array, even for scalar inputs."
+    ],
+    "examples": [
+        {
+            "description": "Find substring positions in a character vector",
+            "input": "idx = strfind('abracadabra', 'abra')",
+            "output": "idx = [1 8]"
+        },
+        {
+            "description": "Locate overlapping matches",
+            "input": "idx = strfind(\"aaaa\", \"aa\")",
+            "output": "idx = [1 2 3]"
+        },
+        {
+            "description": "Return matches for each element of a string array",
+            "input": "words = [\"hydrogen\"; \"helium\"; \"lithium\"];\nidx = strfind(words, \"i\")",
+            "output": "idx = 3×1 cell array\n    {[]}\n    {[4]}\n    {[2 5]}"
+        },
+        {
+            "description": "Search with multiple patterns against one subject",
+            "input": "idx = strfind(\"saturn\", [\"sat\", \"turn\", \"moon\"])",
+            "output": "idx = 1×3 cell array\n    {[1]}    {[3]}    {[]}"
+        },
+        {
+            "description": "Force cell output for scalar inputs",
+            "input": "idx = strfind('mission', 's', 'ForceCellOutput', true)",
+            "output": "idx = 1×1 cell array\n    {[3 4]}"
+        },
+        {
+            "description": "Handle empty patterns and missing strings",
+            "input": "idxEmpty = strfind(\"abc\", \"\");\nidxMissing = strfind(\"<missing>\", \"abc\")",
+            "output": "idxEmpty = [1 2 3 4];\nidxMissing = []"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What types can I pass to `strfind`?",
+            "answer": "Use string scalars/arrays, character vectors/arrays, or cell arrays of character vectors for either argument. Mixed combinations are allowed; MATLAB-style implicit expansion aligns the inputs automatically."
+        },
+        {
+            "question": "How are the results formatted?",
+            "answer": "When both inputs are scalar text (character vectors or string scalars) and `'ForceCellOutput'` is `false`, `strfind` returns a numeric row vector with the starting indices. In all other cases — for example, if either input is a cell array or the broadcasted size exceeds one element — the result is a cell array whose shape matches the broadcasted size, with each cell containing a row vector of doubles."
+        },
+        {
+            "question": "Do matches overlap?",
+            "answer": "Yes. The builtin considers every occurrence of the pattern, including overlapping matches."
+        },
+        {
+            "question": "What happens with empty patterns?",
+            "answer": "An empty pattern matches the gaps between characters, so the indices `1:length(str)+1` are returned for non-missing text. When the subject is missing, the result is an empty array."
+        },
+        {
+            "question": "How do I always get a cell array?",
+            "answer": "Supply `'ForceCellOutput', true`. This mirrors MATLAB and is useful when you want consistent cell outputs regardless of input sizes."
+        },
+        {
+            "question": "Does `strfind` support case-insensitive matching?",
+            "answer": "No. `strfind` is case-sensitive like MATLAB. Use `contains`, `startsWith`, or the regular expression functions when you need case-insensitive searches."
+        }
+    ],
+    "links": [
+        {
+            "label": "`contains`",
+            "url": "./contains"
+        },
+        {
+            "label": "`startsWith`",
+            "url": "./startswith"
+        },
+        {
+            "label": "`endsWith`",
+            "url": "./endswith"
+        },
+        {
+            "label": "`regexp`",
+            "url": "./regexp"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/search/strfind.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/search/strfind.rs"
+    },
+    "gpu_residency": "You usually do NOT need to call `gpuArray` yourself in RunMat (unlike MATLAB).\n\n`strfind` always executes on the host, but if you pass in GPU-resident values RunMat gathers them automatically before performing the search. This keeps the results identical to MATLAB while still allowing upstream computations to benefit from acceleration.",
+    "gpu_behavior": [
+        "`strfind` performs substring searches on the host CPU. When its inputs currently live on the GPU (for example, after other accelerated operations), RunMat gathers them automatically before executing the search so the behaviour matches MATLAB exactly. No provider hooks are required."
+    ],
+    "key": "strfind",
+    "slug": "strfind",
+    "categoryPath": [
+        "strings",
+        "search"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=strfind.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strfind.js","sourceRoot":"","sources":["../../../src/generated/builtins/strfind.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,gBAAgB;IAC5B,UAAU,EAAE;QACV,SAAS;QACT,WAAW;QACX,OAAO;QACP,WAAW;QACX,iBAAiB;KAClB;IACD,SAAS,EAAE,8GAA8G;IACzH,YAAY,EAAE;QACZ,wDAAwD;KACzD;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,yGAAyG;KACnH;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,qFAAqF;KACrG;IACD,aAAa,EAAE,0OAA0O;IACzP,WAAW,EAAE;QACX,gJAAgJ;QAChJ,6EAA6E;QAC7E,6UAA6U;QAC7U,+GAA+G;QAC/G,yJAAyJ;QACzJ,0FAA0F;KAC3F;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,sCAAsC;YAC/C,QAAQ,EAAE,aAAa;SACxB;QACD;YACE,aAAa,EAAE,4BAA4B;YAC3C,OAAO,EAAE,iCAAiC;YAC1C,QAAQ,EAAE,eAAe;SAC1B;QACD;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,+EAA+E;YACxF,QAAQ,EAAE,wDAAwD;SACnE;QACD;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,0DAA0D;YACnE,QAAQ,EAAE,kDAAkD;SAC7D;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,wDAAwD;YACjE,QAAQ,EAAE,mCAAmC;SAC9C;QACD;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,kFAAkF;YAC3F,QAAQ,EAAE,wCAAwC;SACnD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,gNAAgN;SAC3N;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,sZAAsZ;SACja;QACD;YACE,UAAU,EAAE,qBAAqB;YACjC,QAAQ,EAAE,4FAA4F;SACvG;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,sLAAsL;SACjM;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,sIAAsI;SACjJ;QACD;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,yJAAyJ;SACpK;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,cAAc;YACvB,KAAK,EAAE,cAAc;SACtB;QACD;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,gEAAgE;QACzE,KAAK,EAAE,6GAA6G;KACrH;IACD,eAAe,EAAE,qVAAqV;IACtW,cAAc,EAAE;QACd,4RAA4R;KAC7R;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,cAAc,EAAE;QACd,SAAS;QACT,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/string.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/string.empty.d.ts

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

package/dist/generated/builtins/string.empty.d.ts.map

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

package/dist/generated/builtins/string.empty.js

@@ -0,0 +1,198 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "string.empty",
+    "category": "strings/core",
+    "keywords": [
+        "string.empty",
+        "empty string array",
+        "preallocate text",
+        "size vector",
+        "0-by-N",
+        "'like'"
+    ],
+    "summary": "Construct empty string arrays with MATLAB-compatible dimension semantics and 'like' prototypes.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/string.empty.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Creates host string arrays; GPU tensors are neither read nor written."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::core::string_empty::tests"
+    },
+    "description": "`string.empty` constructs an empty string array. By default it returns a `0×0` array, and when you specify additional dimensions they define the trailing extents while the leading dimension remains zero, ensuring the total element count is zero. This mirrors MATLAB's static `string.empty` method.",
+    "behaviors": [
+        "`string.empty` with no arguments yields a `0×0` string array.",
+        "`string.empty(n)` produces a `0×n` array. The leading dimension is fixed at `0`, so the result is still empty even if `n > 0`.",
+        "`string.empty(m, n, p, ...)` returns a `0×n×p×…` array. All trailing dimensions are honoured while the leading dimension remains zero.",
+        "You can provide a single size vector such as `string.empty([0 5 3])`; the first entry is ignored beyond confirming it is non-negative, and the remaining entries set the trailing dimensions.",
+        "`string.empty(___, 'like', prototype)` copies the trailing dimensions from `prototype` when you do not supply explicit sizes. Any dimensions you pass explicitly take precedence. GPU-resident prototypes are automatically gathered so their shape can be inspected.",
+        "Size inputs must be finite, real, non-negative integers. Fractional or negative values produce a MATLAB-compatible error.",
+        "The result always resides on the host; there is no GPU counterpart for string arrays."
+    ],
+    "examples": [
+        {
+            "description": "Creating a 0x0 string array",
+            "input": "S = string.empty",
+            "output": "S =\n  0x0 string array"
+        },
+        {
+            "description": "Building a 0xN string row vector",
+            "input": "row = string.empty(5)",
+            "output": "row =\n  0x5 string array"
+        },
+        {
+            "description": "Creating a 0xN string array with extra dimensions",
+            "input": "cube = string.empty(0, 4, 3)",
+            "output": "cube =\n  0x4x3 string array"
+        },
+        {
+            "description": "Using a size vector with string.empty",
+            "input": "sz = [0 2 5];\ngrid = string.empty(sz)",
+            "output": "grid =\n  0x2x5 string array"
+        },
+        {
+            "description": "Resetting a preallocated string array to empty",
+            "input": "A = strings(3, 2);  % Some application-specific strings\nA = string.empty(size(A))",
+            "output": "A =\n  0x2 string array"
+        },
+        {
+            "description": "Preserving higher-dimensional layout while empty",
+            "input": "layout = string.empty([2 0 4 6])",
+            "output": "layout =\n  0x0x4x6 string array"
+        },
+        {
+            "description": "Reusing the shape of an existing array with `'like'`",
+            "input": "proto = strings(3, 2);\nsameCols = string.empty('like', proto)",
+            "output": "sameCols =\n  0x2 string array"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why is the first dimension always zero?",
+            "answer": "MATLAB defines `classname.empty` so that the leading dimension is zero, guaranteeing the result contains no elements. RunMat mirrors this rule for perfect compatibility."
+        },
+        {
+            "question": "Can I request negative or fractional dimensions?",
+            "answer": "No. Dimensions must be finite, non-negative integers. Any other input raises a descriptive error."
+        },
+        {
+            "question": "Does `string.empty(n)` create space for `n` elements?",
+            "answer": "No. It returns a `0×n` array, which still has zero elements. Use `strings(n)` if you want an array of string scalars that you can fill later."
+        },
+        {
+            "question": "Can I combine scalars and size vectors?",
+            "answer": "Yes. Calls like `string.empty([0 3], 5)` flatten to `string.empty(0, 3, 5)` internally."
+        },
+        {
+            "question": "What does the `'like'` option do?",
+            "answer": "`'like', prototype` copies the trailing dimensions from `prototype` when you omit explicit sizes. The first dimension is still forced to `0`, so the result remains empty. The prototype is gathered automatically if it resides on the GPU."
+        },
+        {
+            "question": "Does the result share storage with existing arrays?",
+            "answer": "No. Every call returns a new handle. Because the array is empty, the data buffer is an empty vector and consumes negligible memory."
+        },
+        {
+            "question": "Is there a GPU-accelerated variant?",
+            "answer": "No. String arrays live on the host in RunMat, and this builtin never touches GPU memory."
+        },
+        {
+            "question": "How do I obtain a 0x0 string array quickly?",
+            "answer": "Call `string.empty` with no arguments. It is equivalent to `strings(0)` but makes the intention explicit."
+        },
+        {
+            "question": "Can I use `size` output directly?",
+            "answer": "Yes. Expressions like `string.empty(size(existingArray))` are supported. The first element of the size vector is ignored when constructing the new array so that the first dimension is zero."
+        },
+        {
+            "question": "What happens if I pass an empty array as the size vector?",
+            "answer": "`string.empty([])` returns the canonical `0×0` string array, just like calling `string.empty` with no arguments."
+        },
+        {
+            "question": "Does `string.empty` ever throw away extra arguments?",
+            "answer": "Only when they cannot be interpreted as dimensions. In that case RunMat throws an error rather than guessing."
+        }
+    ],
+    "links": [
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "strings",
+            "url": "./strings"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "zeros",
+            "url": "./zeros"
+        },
+        {
+            "label": "ones",
+            "url": "./ones"
+        },
+        {
+            "label": "compose",
+            "url": "./compose"
+        },
+        {
+            "label": "num2str",
+            "url": "./num2str"
+        },
+        {
+            "label": "sprintf",
+            "url": "./sprintf"
+        },
+        {
+            "label": "str2double",
+            "url": "./str2double"
+        },
+        {
+            "label": "strcmp",
+            "url": "./strcmp"
+        },
+        {
+            "label": "strcmpi",
+            "url": "./strcmpi"
+        },
+        {
+            "label": "strlength",
+            "url": "./strlength"
+        },
+        {
+            "label": "strncmp",
+            "url": "./strncmp"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/core/string.empty.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/core/string.empty.rs"
+    },
+    "gpu_residency": "No. `string.empty` allocates metadata for an empty string array entirely on the host. Because the result contains no elements and string scalars are host-only, there is nothing to transfer to or from the GPU. Using `gpuArray` with `string.empty` has no effect and is unnecessary.",
+    "gpu_behavior": [
+        "`string.empty` does not allocate or interact with GPU memory. It is a pure host constructor that instantly returns the requested shape metadata and an empty data buffer. When the runtime is executing under RunMat Accelerate, no provider hooks are invoked. `'like'` prototypes that happen to live on the GPU are gathered to the host before their shape is examined."
+    ],
+    "key": "string.empty",
+    "slug": "string.empty",
+    "categoryPath": [
+        "strings",
+        "core"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=string.empty.js.map

package/dist/generated/builtins/string.empty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.empty.js","sourceRoot":"","sources":["../../../src/generated/builtins/string.empty.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,cAAc;IACvB,UAAU,EAAE,cAAc;IAC1B,UAAU,EAAE;QACV,cAAc;QACd,oBAAoB;QACpB,kBAAkB;QAClB,aAAa;QACb,QAAQ;QACR,QAAQ;KACT;IACD,SAAS,EAAE,iGAAiG;IAC5G,YAAY,EAAE;QACZ,6DAA6D;KAC9D;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uEAAuE;KACjF;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,8CAA8C;KACvD;IACD,aAAa,EAAE,2SAA2S;IAC1T,WAAW,EAAE;QACX,+DAA+D;QAC/D,gIAAgI;QAChI,wIAAwI;QACxI,+LAA+L;QAC/L,uQAAuQ;QACvQ,2HAA2H;QAC3H,uFAAuF;KACxF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,kBAAkB;YAC3B,QAAQ,EAAE,yBAAyB;SACpC;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,uBAAuB;YAChC,QAAQ,EAAE,2BAA2B;SACtC;QACD;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,8BAA8B;YACvC,QAAQ,EAAE,8BAA8B;SACzC;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,wCAAwC;YACjD,QAAQ,EAAE,8BAA8B;SACzC;QACD;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,oFAAoF;YAC7F,QAAQ,EAAE,yBAAyB;SACpC;QACD;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,kCAAkC;YAC3C,QAAQ,EAAE,kCAAkC;SAC7C;QACD;YACE,aAAa,EAAE,sDAAsD;YACrE,OAAO,EAAE,gEAAgE;YACzE,QAAQ,EAAE,gCAAgC;SAC3C;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,2KAA2K;SACtL;QACD;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,mGAAmG;SAC9G;QACD;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,+IAA+I;SAC1J;QACD;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,yFAAyF;SACpG;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,8OAA8O;SACzP;QACD;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,qIAAqI;SAChJ;QACD;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,0FAA0F;SACrG;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,2GAA2G;SACtH;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,+LAA+L;SAC1M;QACD;YACE,UAAU,EAAE,2DAA2D;YACvE,QAAQ,EAAE,kHAAkH;SAC7H;QACD;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,+GAA+G;SAC1H;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,cAAc;SACtB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,mEAAmE;QAC5E,KAAK,EAAE,gHAAgH;KACxH;IACD,eAAe,EAAE,yRAAyR;IAC1S,cAAc,EAAE;QACd,6WAA6W;KAC9W;IACD,KAAK,EAAE,cAAc;IACrB,MAAM,EAAE,cAAc;IACtB,cAAc,EAAE;QACd,SAAS;QACT,MAAM;KACP;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/string.js

@@ -0,0 +1,189 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "string",
+    "category": "strings/core",
+    "keywords": [
+        "string",
+        "convert",
+        "text",
+        "char",
+        "gpu"
+    ],
+    "summary": "Convert numeric, logical, character, and text inputs into MATLAB string arrays, with optional format-spec composition.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/string.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Gather-only conversion that downloads GPU tensors to host memory before producing string scalars."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::core::string::tests",
+        "integration": "builtins::strings::core::string::tests::string_gpu_numeric_tensor"
+    },
+    "description": "`string(x)` converts scalars, arrays, and text-like inputs into MATLAB string arrays whose elements are string scalars. Numeric and logical values are formatted using MATLAB's short-`g` style, character arrays are split by row, and existing string arrays pass through unchanged.",
+    "behaviors": [
+        "Scalar inputs return a `1×1` string array containing the converted value.",
+        "Numeric and logical arrays preserve the original shape while converting each element.",
+        "Character arrays turn into columnar string arrays with one row per original row.",
+        "Cell arrays must contain text-like or scalar numeric values; each cell becomes one string scalar.",
+        "`string(formatSpec, A1, ..., An)` formats data using MATLAB-compatible `%` placeholders. Scalar format specs broadcast across array arguments and arrays of specs align element-wise.",
+        "Empty inputs yield empty string arrays that match MATLAB's dimension rules.",
+        "Unsupported types (structs, handle objects, events, functions) raise MATLAB-compatible errors."
+    ],
+    "examples": [
+        {
+            "description": "Converting A Numeric Scalar To A String",
+            "input": "name = string(42)",
+            "output": "name = \"42\""
+        },
+        {
+            "description": "Turning A Numeric Row Vector Into Strings",
+            "input": "values = string([3.14159 2.71828 1.41421])",
+            "output": "values = 1×3 string\n    \"3.1416\"    \"2.7183\"    \"1.4142\""
+        },
+        {
+            "description": "Converting A Character Matrix Into A String Array",
+            "input": "C = ['North '; 'South '; 'East  '; 'West  '];\nregions = string(C)",
+            "output": "regions = 4×1 string\n    \"North \"\n    \"South \"\n    \"East  \"\n    \"West  \""
+        },
+        {
+            "description": "Converting Logical Data To String Scalars",
+            "input": "flags = string(logical([1 0 1 0]))",
+            "output": "flags = 1×4 string\n    \"true\"    \"false\"    \"true\"    \"false\""
+        },
+        {
+            "description": "Creating Strings From A Cell Array Of Mixed Scalars",
+            "input": "C = {true, 17, \"runmat\"};\nS = string(C)",
+            "output": "S = 1×3 string\n    \"true\"    \"17\"    \"runmat\""
+        },
+        {
+            "description": "Formatting Numbers With A Template",
+            "input": "labels = string(\"Trial %d\", 1:4)",
+            "output": "labels = 1×4 string\n    \"Trial 1\"    \"Trial 2\"    \"Trial 3\"    \"Trial 4\""
+        },
+        {
+            "description": "Converting GPU-Resident Numeric Data To Strings",
+            "input": "G = gpuArray([10 20 30]);\nlabels = string(G)",
+            "output": "labels = 1×3 string\n    \"10\"    \"20\"    \"30\""
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `string` change the size of my array?",
+            "answer": "No. Array-shaped inputs return string arrays with the same shape. Character arrays become column vectors where each row of characters maps to one string scalar."
+        },
+        {
+            "question": "How are floating-point numbers formatted?",
+            "answer": "Floating-point values use MATLAB's short-`g` formatting (up to 12 significant digits) so the result matches `disp` output and is consistent across CPU and GPU inputs."
+        },
+        {
+            "question": "Can I use format specifiers like `%0.2f`?",
+            "answer": "Yes. Provide a format string as the first argument and pass the values to substitute in the remaining arguments, e.g. `string(\"Value %0.2f\", A)` or `string([\"X%02d\" \"Y%02d\"], 1:2)`. Scalar format specs broadcast across vector inputs following MATLAB's rules."
+        },
+        {
+            "question": "What happens if I pass a GPU tensor?",
+            "answer": "The builtin downloads the tensor using the active acceleration provider and then performs the conversion on the CPU. The resulting string array always resides in host memory."
+        },
+        {
+            "question": "Can I request a specific character encoding?",
+            "answer": "RunMat currently supports UTF-8 (the default). Passing `'UTF-8'`, `'utf8'`, or `'system'` yields the same behaviour. Other encodings raise a descriptive error."
+        },
+        {
+            "question": "Can I convert complex numbers or complex arrays?",
+            "answer": "Yes. Complex scalars and arrays use MATLAB's `a + bi` formatting, with imaginary values rendered using the `i` suffix."
+        },
+        {
+            "question": "What happens with empty inputs?",
+            "answer": "Empty inputs return empty string arrays following MATLAB's dimension rules—for example, `string([])` yields a `0×0` string array, and `string(char.empty(0,5))` yields a `0×1` string array."
+        },
+        {
+            "question": "Why does `string` error on structs or handle objects?",
+            "answer": "MATLAB's `string` only supports text-like or scalar numeric types. Structs, objects, listeners, and other handle types cannot be converted automatically and therefore raise an error in RunMat as well."
+        },
+        {
+            "question": "How can I keep trailing spaces from character arrays?",
+            "answer": "`string` preserves every character, including trailing spaces. Use `strtrim` afterwards if you want to remove padding."
+        },
+        {
+            "question": "Do existing string arrays change when passed to `string`?",
+            "answer": "No. Existing string arrays pass through unchanged, so `string([\"a\" \"b\"])` returns the same array."
+        }
+    ],
+    "links": [
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "cellstr",
+            "url": "./cellstr"
+        },
+        {
+            "label": "string.empty",
+            "url": "./string.empty"
+        },
+        {
+            "label": "strings",
+            "url": "./strings"
+        },
+        {
+            "label": "compose",
+            "url": "./compose"
+        },
+        {
+            "label": "num2str",
+            "url": "./num2str"
+        },
+        {
+            "label": "sprintf",
+            "url": "./sprintf"
+        },
+        {
+            "label": "str2double",
+            "url": "./str2double"
+        },
+        {
+            "label": "strcmp",
+            "url": "./strcmp"
+        },
+        {
+            "label": "strcmpi",
+            "url": "./strcmpi"
+        },
+        {
+            "label": "strlength",
+            "url": "./strlength"
+        },
+        {
+            "label": "strncmp",
+            "url": "./strncmp"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/core/string.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/core/string.rs"
+    },
+    "gpu_behavior": [
+        "`string` is a residency sink. When the input contains GPU tensors, RunMat gathers the data back to host memory before performing the conversion. Providers do not need bespoke kernels—the CPU path is authoritative and ensures identical formatting across devices."
+    ],
+    "key": "string",
+    "slug": "string",
+    "categoryPath": [
+        "strings",
+        "core"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=string.js.map

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

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

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

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

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

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