runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/strings.js

@@ -0,0 +1,188 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "strings",
+    "category": "strings/core",
+    "keywords": [
+        "strings",
+        "preallocate",
+        "string array",
+        "empty strings",
+        "missing",
+        "like",
+        "gpu"
+    ],
+    "summary": "Preallocate string arrays filled with empty text scalars using MATLAB-compatible size syntax.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/strings.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs entirely on the host; GPU-resident size inputs are gathered before allocation and outputs always live in host memory."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::core::strings::tests"
+    },
+    "description": "`strings` creates string arrays whose elements are empty string scalars (`\"\"`). It mirrors MATLAB's preallocation helper, accepting scalar, vector, or multiple dimension arguments to control the array shape.",
+    "behaviors": [
+        "`strings` with no inputs returns a 1×1 string array containing `\"\"`.",
+        "`strings(n)` produces an `n`-by-`n` array of empty strings. The single input must be a nonnegative integer scalar.",
+        "`strings(sz1,...,szN)` and `strings(sz)` accept nonnegative integer sizes. All specified dimensions—including trailing singletons—are preserved in the resulting array.",
+        "Setting any dimension to `0` yields an empty array whose remaining dimensions still shape the result (for example, `strings(0, 5, 3)` is a `0×5×3` string array).",
+        "`strings(___, \"missing\")` fills the allocation with the missing sentinel (`<missing>`) instead of empty strings, which is useful when you plan to replace placeholders later.",
+        "`strings(___, \"like\", prototype)` or `strings(\"like\", prototype)` reuses the size of `prototype` when you omit explicit dimensions. Any provided dimensions still take precedence, and GPU prototypes are gathered before their shape is inspected.",
+        "Size inputs must be finite integers. Negative, fractional, or NaN values trigger MATLAB-compatible \"Size inputs must be nonnegative integers\" errors.",
+        "Only numeric or logical size arguments are supported. Other types (strings, structs, objects) raise descriptive errors."
+    ],
+    "examples": [
+        {
+            "description": "Creating a square array of empty strings",
+            "input": "S = strings(4)",
+            "output": "S = 4x4 string\n    \"\"    \"\"    \"\"    \"\"\n    \"\"    \"\"    \"\"    \"\"\n    \"\"    \"\"    \"\"    \"\"\n    \"\"    \"\"    \"\"    \"\""
+        },
+        {
+            "description": "Preallocating with separate dimension arguments",
+            "input": "grid = strings(2, 3, 4)",
+            "output": "grid = 2x3x4 string\ngrid(:,:,1) =\n    \"\"    \"\"    \"\"\n    \"\"    \"\"    \"\""
+        },
+        {
+            "description": "Cloning the size of another array",
+            "input": "A = magic(3);\nplaceholders = strings(size(A))",
+            "output": "placeholders = 3x3 string\n    \"\"    \"\"    \"\"\n    \"\"    \"\"    \"\"\n    \"\"    \"\"    \"\""
+        },
+        {
+            "description": "Handling zero dimensions",
+            "input": "emptyRow = strings(0, 5)",
+            "output": "emptyRow = 0x5 string"
+        },
+        {
+            "description": "Preserving trailing singleton dimensions",
+            "input": "column = strings(3, 1, 1, 1);\nsz = size(column)",
+            "output": "sz =\n     3     1     1     1"
+        },
+        {
+            "description": "Filling arrays with missing string scalars",
+            "input": "placeholders = strings(2, 3, \"missing\")",
+            "output": "placeholders = 2x3 string\n    <missing>    <missing>    <missing>\n    <missing>    <missing>    <missing>"
+        },
+        {
+            "description": "Matching an existing array with `'like'`",
+            "input": "proto = zeros(3, 2);\nlabels = strings(\"like\", proto)",
+            "output": "labels = 3x2 string\n    \"\"    \"\"\n    \"\"    \"\"\n    \"\"    \"\""
+        },
+        {
+            "description": "Validating size inputs",
+            "input": "try\n    strings(-3);\ncatch ME\n    disp(ME.message)\nend",
+            "output": "Error using strings\nSize inputs must be nonnegative integers."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How is `strings` different from `string`?",
+            "answer": "`strings` preallocates empty string scalars, while `string` converts existing data to string scalars. Use `strings` to reserve space, then assign values later."
+        },
+        {
+            "question": "Can I use non-integer sizes such as 2.5?",
+            "answer": "No. All size arguments must be finite integers. Fractional or NaN values raise descriptive errors."
+        },
+        {
+            "question": "How do I create missing string values (`<missing>`)?",
+            "answer": "Pass `\"missing\"` as an option— for example `strings(2, 3, \"missing\")` produces a `2×3` array filled with `<missing>` placeholders. You can still assign values later to replace the sentinel."
+        },
+        {
+            "question": "How can I reuse the size of an existing array?",
+            "answer": "Provide the `\"like\"` option: `strings(\"like\", prototype)` copies the size of `prototype` when you do not supply explicit dimensions. Any dimensions you specify override the inferred size."
+        },
+        {
+            "question": "Does the output ever live on the GPU?",
+            "answer": "No. `strings` always returns a host-resident string array. GPU inputs supplying sizes are gathered before validation."
+        },
+        {
+            "question": "How can I create a row versus column vector?",
+            "answer": "Use `strings(1, n)` for a row and `strings(n, 1)` for a column. Additional dimensions—including trailing singletons—remain part of the array shape."
+        },
+        {
+            "question": "Can I pass non-numeric types such as structs or string arrays as size inputs?",
+            "answer": "No. Only numeric or logical values are accepted. Other types produce MATLAB-compatible usage errors."
+        },
+        {
+            "question": "Is there an equivalent to `string.empty`?",
+            "answer": "Yes. `strings(0)` returns the same 0-by-0 empty string array as `string.empty`."
+        }
+    ],
+    "links": [
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "zeros",
+            "url": "./zeros"
+        },
+        {
+            "label": "string.empty",
+            "url": "./string.empty"
+        },
+        {
+            "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/strings.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/core/strings.rs"
+    },
+    "gpu_behavior": [
+        "`strings` never allocates data on the GPU. Size arguments that reside on a GPU are automatically gathered to the host before validation, and the resulting string array always lives in host memory. `\"like\"` prototypes follow the same rule—they are gathered before their shape is inspected. No provider hooks are required, so the GPU metadata marks the builtin as a gather-only operation."
+    ],
+    "key": "strings",
+    "slug": "strings",
+    "categoryPath": [
+        "strings",
+        "core"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=strings.js.map

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

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

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

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

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

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

package/dist/generated/builtins/strip.js

@@ -0,0 +1,181 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "strip",
+    "category": "strings/transform",
+    "keywords": [
+        "strip",
+        "trim",
+        "whitespace",
+        "leading characters",
+        "trailing characters",
+        "character arrays"
+    ],
+    "summary": "Remove leading and trailing characters from strings, character arrays, and cell arrays.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/strip.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Executes on the CPU; GPU-resident inputs are gathered before trimming to match MATLAB semantics."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::transform::strip::tests",
+        "integration": "builtins::strings::transform::strip::tests::strip_cell_array_mixed_content"
+    },
+    "description": "`strip(text)` removes consecutive whitespace characters from the beginning and end of `text`. The input can be a string scalar, string array, character array, or a cell array of character vectors, mirroring MATLAB behaviour. Optional arguments let you control which side to trim (`'left'`, `'right'`, or `'both'`) and provide custom characters to remove instead of whitespace.",
+    "behaviors": [
+        "By default, `strip` removes leading and trailing whitespace determined by `isspace`.",
+        "Direction keywords are case-insensitive. `'left'`/`'leading'` trim the beginning, `'right'`/`'trailing'` trim the end, and `'both'` removes characters on both sides.",
+        "Provide a second argument containing characters to remove to strip those characters instead of whitespace. Supply a scalar string/char vector to apply the same rule to every element or a string / cell array matching the input size to specify element-wise character sets.",
+        "Missing string scalars remain `<missing>`.",
+        "Character arrays shrink or retain their width to match the longest stripped row; shorter rows are padded with spaces so the output stays rectangular.",
+        "Cell arrays must contain string scalars or character vectors. Results preserve the original cell layout with trimmed elements."
+    ],
+    "examples": [
+        {
+            "description": "Remove Leading And Trailing Spaces From A String Scalar",
+            "input": "name = \"   RunMat   \";\nclean = strip(name)",
+            "output": "clean = \"RunMat\""
+        },
+        {
+            "description": "Trim Only The Right Side Of Each String",
+            "input": "labels = [\"   Alpha   \"; \"   Beta     \"; \"   Gamma    \"];\nright_stripped = strip(labels, 'right')",
+            "output": "right_stripped = 3×1 string\n    \"   Alpha\"\n    \"   Beta\"\n    \"   Gamma\""
+        },
+        {
+            "description": "Remove Leading Zeros While Preserving Trailing Digits",
+            "input": "codes = [\"00095\"; \"00137\"; \"00420\"];\nnumeric = strip(codes, 'left', '0')",
+            "output": "numeric = 3×1 string\n    \"95\"\n    \"137\"\n    \"420\""
+        },
+        {
+            "description": "Strip Character Arrays And Preserve Rectangular Shape",
+            "input": "animals = char(\"   cat  \", \" dog\", \"cow   \");\ntrimmed = strip(animals)",
+            "output": "trimmed =\n\n  3×4 char array\n\n    'cat '\n    'dog '\n    'cow '"
+        },
+        {
+            "description": "Supply Per-Element Characters To Remove",
+            "input": "metrics = [\"##pass##\", \"--warn--\", \"**fail**\"];\nper_char = [\"#\"; \"-\"; \"*\"];\nnormalized = strip(metrics, 'both', per_char)",
+            "output": "normalized = 3×1 string\n    \"pass\"\n    \"warn\"\n    \"fail\""
+        },
+        {
+            "description": "Trim Cell Array Elements With Mixed Types",
+            "input": "pieces = {'  GPU  ', \"   Accelerate\", 'RunMat   '};\nout = strip(pieces)",
+            "output": "out = 1×3 cell array\n    {'GPU'}    {\"Accelerate\"}    {'RunMat'}"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Which direction keywords are supported?",
+            "answer": "`'left'` and `'leading'` trim the beginning of the text, `'right'` and `'trailing'` trim the end, and `'both'` (the default) trims both sides."
+        },
+        {
+            "question": "How do I remove characters other than whitespace?",
+            "answer": "Provide a second argument containing the characters to remove, for example `strip(str, \"xyz\")` removes any leading or trailing `x`, `y`, or `z` characters. Combine it with a direction argument to control which side is affected."
+        },
+        {
+            "question": "Can I specify different characters for each element?",
+            "answer": "Yes. Pass a string array or cell array of character vectors that matches the size of the input. Each element is trimmed using the corresponding character set."
+        },
+        {
+            "question": "What happens to missing strings?",
+            "answer": "Missing string scalars (`string(missing)`) remain `<missing>` exactly as in MATLAB."
+        },
+        {
+            "question": "Does `strip` change the shape of character arrays?",
+            "answer": "Only the width can change. `strip` keeps the same number of rows and pads shorter rows with spaces so the array stays rectangular."
+        },
+        {
+            "question": "Will `strip` run on the GPU?",
+            "answer": "Not currently. RunMat gathers GPU-resident inputs automatically and performs trimming on the CPU to maintain MATLAB compatibility."
+        }
+    ],
+    "links": [
+        {
+            "label": "lower",
+            "url": "./lower"
+        },
+        {
+            "label": "upper",
+            "url": "./upper"
+        },
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "compose",
+            "url": "./compose"
+        },
+        {
+            "label": "erase",
+            "url": "./erase"
+        },
+        {
+            "label": "eraseBetween",
+            "url": "./erasebetween"
+        },
+        {
+            "label": "extractBetween",
+            "url": "./extractbetween"
+        },
+        {
+            "label": "join",
+            "url": "./join"
+        },
+        {
+            "label": "pad",
+            "url": "./pad"
+        },
+        {
+            "label": "replace",
+            "url": "./replace"
+        },
+        {
+            "label": "split",
+            "url": "./split"
+        },
+        {
+            "label": "strcat",
+            "url": "./strcat"
+        },
+        {
+            "label": "strrep",
+            "url": "./strrep"
+        },
+        {
+            "label": "strtrim",
+            "url": "./strtrim"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/transform/strip.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/transform/strip.rs"
+    },
+    "gpu_residency": "Text data typically lives on the host. If you deliberately store text on the GPU (for example, by keeping character code points in device buffers), RunMat gathers them automatically when `strip` runs. You do not need to call `gpuArray` or `gather` manually for this builtin.",
+    "gpu_behavior": [
+        "`strip` executes on the CPU. When the input or any nested element resides on the GPU, RunMat gathers those values to host memory before trimming so the results match MATLAB exactly. Providers do not need to implement device kernels for this builtin today."
+    ],
+    "key": "strip",
+    "slug": "strip",
+    "categoryPath": [
+        "strings",
+        "transform"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=strip.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strip.js","sourceRoot":"","sources":["../../../src/generated/builtins/strip.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,OAAO;QACP,MAAM;QACN,YAAY;QACZ,oBAAoB;QACpB,qBAAqB;QACrB,kBAAkB;KACnB;IACD,SAAS,EAAE,yFAAyF;IACpG,YAAY,EAAE;QACZ,sDAAsD;KACvD;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,kGAAkG;KAC5G;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,4EAA4E;KAC5F;IACD,aAAa,EAAE,0XAA0X;IACzY,WAAW,EAAE;QACX,sFAAsF;QACtF,uKAAuK;QACvK,gRAAgR;QAChR,4CAA4C;QAC5C,uJAAuJ;QACvJ,gIAAgI;KACjI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yDAAyD;YACxE,OAAO,EAAE,+CAA+C;YACxD,QAAQ,EAAE,oBAAoB;SAC/B;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,0GAA0G;YACnH,QAAQ,EAAE,kFAAkF;SAC7F;QACD;YACE,aAAa,EAAE,uDAAuD;YACtE,OAAO,EAAE,iFAAiF;YAC1F,QAAQ,EAAE,4DAA4D;SACvE;QACD;YACE,aAAa,EAAE,uDAAuD;YACtE,OAAO,EAAE,+EAA+E;YACxF,QAAQ,EAAE,qEAAqE;SAChF;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,yIAAyI;YAClJ,QAAQ,EAAE,mEAAmE;SAC9E;QACD;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,4EAA4E;YACrF,QAAQ,EAAE,qEAAqE;SAChF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,gJAAgJ;SAC3J;QACD;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,uOAAuO;SAClP;QACD;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,gKAAgK;SAC3K;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,qFAAqF;SAChG;QACD;YACE,UAAU,EAAE,oDAAoD;YAChE,QAAQ,EAAE,oIAAoI;SAC/I;QACD;YACE,UAAU,EAAE,8BAA8B;YAC1C,QAAQ,EAAE,oIAAoI;SAC/I;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;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,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,eAAe,EAAE,oRAAoR;IACrS,cAAc,EAAE;QACd,iQAAiQ;KAClQ;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,cAAc,EAAE;QACd,SAAS;QACT,WAAW;KACZ;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/strlength.js

@@ -0,0 +1,174 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "strlength",
+    "category": "strings/core",
+    "keywords": [
+        "strlength",
+        "string length",
+        "character count",
+        "text analytics",
+        "cell array"
+    ],
+    "summary": "Return the number of characters in each element of a string array, character array, or cell array of character vectors.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/strlength.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Executes on the CPU; if any argument lives on the GPU, the runtime gathers it before computing lengths to keep semantics identical to MATLAB."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::core::strlength::tests",
+        "integration": "builtins::strings::core::strlength::tests::strlength_cell_array_of_char_vectors"
+    },
+    "description": "`strlength(str)` counts how many characters appear in each element of text inputs. It works with string arrays, character vectors, character arrays, and cell arrays of character vectors, returning a `double` array that mirrors the input shape.",
+    "behaviors": [
+        "String arrays return a numeric array of the same size; string scalars yield a scalar `double`.",
+        "Character arrays report the number of characters per row and ignore padding that MATLAB inserts to keep rows the same width.",
+        "Character vectors stored in cells contribute one scalar per cell element; the output array matches the cell array shape.",
+        "Missing string scalars (for example values created with `string(missing)`) yield `NaN`. RunMat displays these entries as `<missing>` in the console just like MATLAB.",
+        "Empty text inputs produce zeros-sized numeric outputs that match MATLAB's dimension rules."
+    ],
+    "examples": [
+        {
+            "description": "Measure Characters In A String Scalar",
+            "input": "len = strlength(\"RunMat\")",
+            "output": "len = 6"
+        },
+        {
+            "description": "Count Characters Across A String Array",
+            "input": "labels = [\"North\" \"South\" \"East\" \"West\"];\ncounts = strlength(labels)",
+            "output": "counts = 1×4\n    5    5    4    4"
+        },
+        {
+            "description": "Compute Lengths For Each Row Of A Character Array",
+            "input": "names = char(\"cat\", \"giraffe\");\nrow_counts = strlength(names)",
+            "output": "row_counts = 2×1\n     3\n     7"
+        },
+        {
+            "description": "Handle Empty And Blank Strings",
+            "input": "mixed = [\"\", \"   \"];\nlen = strlength(mixed)",
+            "output": "len = 1×2\n     0     3"
+        },
+        {
+            "description": "Get Lengths From A Cell Array Of Character Vectors",
+            "input": "C = {'red', 'green', 'blue'};\nL = strlength(C)",
+            "output": "L = 1×3\n     3     5     4"
+        },
+        {
+            "description": "Treat Missing Strings As NaN",
+            "input": "values = string([\"alpha\" \"beta\" \"gamma\"]);\nvalues(2) = string(missing);  % Displays as <missing> when printed\nlengths = strlength(values)",
+            "output": "lengths = 1×3\n    5   NaN    5"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What numeric type does `strlength` return?",
+            "answer": "`strlength` always returns doubles, even when all lengths are whole numbers. MATLAB uses doubles for most numeric results, and RunMat follows the same rule."
+        },
+        {
+            "question": "Why are padded spaces in character arrays ignored?",
+            "answer": "When MATLAB builds a character array from rows of different lengths, it pads shorter rows with spaces. Those padding characters are not part of the logical content, so `strlength` removes them before counting. Explicit trailing spaces that you type in a single character vector remain part of the count."
+        },
+        {
+            "question": "How are missing string values handled?",
+            "answer": "Missing string scalars display as `<missing>` and produce `NaN` lengths. Use `ismissing` or `fillmissing` if you need to substitute a default length."
+        },
+        {
+            "question": "Can I call `strlength` with numeric data?",
+            "answer": "No. `strlength` only accepts string arrays, character vectors/arrays, or cell arrays of character vectors. Numeric inputs raise an error—use `num2str` first if you need to convert numbers to text."
+        },
+        {
+            "question": "Does `strlength` support multibyte Unicode characters?",
+            "answer": "Yes. Each Unicode scalar value counts as one character, so emoji or accented letters contribute a length of one. Surrogate pairs are treated as a single character, matching MATLAB's behaviour."
+        },
+        {
+            "question": "Will `strlength` ever execute on the GPU?",
+            "answer": "No. The builtin inspects metadata and operates on host strings. If your data already lives on the GPU, RunMat gathers it automatically before computing lengths so results match MATLAB exactly."
+        }
+    ],
+    "links": [
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "strtrim",
+            "url": "./strtrim"
+        },
+        {
+            "label": "length",
+            "url": "./length"
+        },
+        {
+            "label": "size",
+            "url": "./size"
+        },
+        {
+            "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": "string.empty",
+            "url": "./string.empty"
+        },
+        {
+            "label": "strings",
+            "url": "./strings"
+        },
+        {
+            "label": "strncmp",
+            "url": "./strncmp"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/core/strlength.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/core/strlength.rs"
+    },
+    "gpu_behavior": [
+        "`strlength` is a metadata query and always executes on the CPU. If a text container references data that originated on the GPU (for example, a cell array that still wraps GPU-resident numeric intermediates), RunMat gathers that data before measuring lengths. Providers do not require custom kernels for this builtin."
+    ],
+    "key": "strlength",
+    "slug": "strlength",
+    "categoryPath": [
+        "strings",
+        "core"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=strlength.js.map

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

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

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

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

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

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