runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/strcat.js

@@ -0,0 +1,180 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "strcat",
+    "category": "strings/transform",
+    "keywords": [
+        "strcat",
+        "string concatenation",
+        "character arrays",
+        "cell arrays",
+        "trailing spaces"
+    ],
+    "summary": "Concatenate text inputs element-wise with MATLAB-compatible trimming and implicit expansion.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/strcat.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "matlab",
+        "notes": "Executes on the CPU; GPU-resident inputs are gathered before concatenation so trimming semantics match MATLAB."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 8,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::transform::strcat::tests",
+        "integration": "builtins::strings::transform::strcat::tests::strcat_cell_array_trims_trailing_spaces"
+    },
+    "description": "`strcat` horizontally concatenates text inputs element-wise. It accepts string arrays, character arrays, character vectors, and cell arrays of character vectors, applying MATLAB's implicit expansion rules to match array sizes.",
+    "behaviors": [
+        "Inputs are concatenated element-wise. Scalars expand across arrays of matching dimensions using MATLAB's implicit expansion rules.",
+        "When at least one input is a string array (or string scalar), the result is a string array. `<missing>` values propagate, so any missing operand yields a missing result for that element.",
+        "When no string arrays are present but any input is a cell array of character vectors, the result is a cell array whose elements are character vectors.",
+        "Otherwise, the result is a character array. For character inputs, `strcat` removes trailing space characters from each operand **before** concatenating.",
+        "Cell array elements must be character vectors (or string scalars). Mixing cell arrays with unsupported content raises a MATLAB-compatible error.",
+        "Empty inputs broadcast naturally: an operand with a zero-length dimension yields an empty output after broadcasting."
+    ],
+    "examples": [
+        {
+            "description": "Concatenate string scalars element-wise",
+            "input": "greeting = strcat(\"Run\", \"Mat\")",
+            "output": "greeting = \"RunMat\""
+        },
+        {
+            "description": "Concatenate a string scalar with a string array",
+            "input": "names = [\"Ignition\", \"Turbine\", \"Accelerate\"];\ntagged = strcat(\"runmat-\", names)",
+            "output": "tagged = 1×3 string\n    \"runmat-Ignition\"    \"runmat-Turbine\"    \"runmat-Accelerate\""
+        },
+        {
+            "description": "Concatenate character arrays while trimming trailing spaces",
+            "input": "A = char(\"GPU \", \"Planner\");\nB = char(\"Accel\", \" Stage \");\nresult = strcat(A, B)",
+            "output": "result =\n\n  2×11 char array\n\n    'GPUAccel'\n    'PlannerStage'"
+        },
+        {
+            "description": "Concatenate cell arrays of character vectors",
+            "input": "C = {'Run ', 'Plan '; 'Fuse ', 'Cache '};\nsuffix = {'Mat', 'Ops'; 'Kernels', 'Stats'};\ncombined = strcat(C, suffix)",
+            "output": "combined = 2×2 cell\n    {'RunMat'}    {'PlanOps'}\n    {'FuseKernels'}    {'CacheStats'}"
+        },
+        {
+            "description": "Propagate missing strings during concatenation",
+            "input": "values = [string(missing) \"ready\"];\nout = strcat(\"job-\", values)",
+            "output": "out = 1×2 string\n    <missing>    \"job-ready\""
+        },
+        {
+            "description": "Broadcast a scalar character vector across a character array",
+            "input": "labels = char(\"core\", \"runtime\", \"planner\");\nprefixed = strcat(\"runmat-\", labels)",
+            "output": "prefixed =\n\n  3×11 char array\n\n    'runmat-core'\n    'runmat-runtime'\n    'runmat-planner'"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `strcat` remove spaces between words?",
+            "answer": "No. `strcat` only strips trailing **space characters** from character inputs before concatenating. Spaces in the middle of a string remain untouched. To insert separators explicitly, concatenate the desired delimiter or use `join`."
+        },
+        {
+            "question": "How are missing strings handled?",
+            "answer": "Missing string scalars (`string(missing)`) propagate. If any operand is missing for a specific element, the resulting element is `<missing>`."
+        },
+        {
+            "question": "What happens when I mix strings and character arrays?",
+            "answer": "The output is a string array. Character inputs are converted to strings (after trimming trailing spaces) and combined element-wise with the string operands."
+        },
+        {
+            "question": "Can I concatenate cell arrays with string arrays?",
+            "answer": "Yes. Inputs are implicitly converted to strings when any operand is a string array, so the result is a string array. Cell array elements must still contain character vectors (or scalar strings)."
+        },
+        {
+            "question": "What if I pass numeric or logical inputs?",
+            "answer": "`strcat` only accepts strings, character arrays, character vectors, or cell arrays of character vectors. Passing unsupported types raises a MATLAB-compatible error."
+        },
+        {
+            "question": "How are empty inputs treated?",
+            "answer": "Dimensions with length zero propagate through implicit expansion. For example, concatenating with an empty string array returns an empty array with the broadcasted shape."
+        }
+    ],
+    "links": [
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "plus",
+            "url": "./plus"
+        },
+        {
+            "label": "join",
+            "url": "./join"
+        },
+        {
+            "label": "cellstr",
+            "url": "./cellstr"
+        },
+        {
+            "label": "erase",
+            "url": "./erase"
+        },
+        {
+            "label": "eraseBetween",
+            "url": "./erasebetween"
+        },
+        {
+            "label": "extractBetween",
+            "url": "./extractbetween"
+        },
+        {
+            "label": "lower",
+            "url": "./lower"
+        },
+        {
+            "label": "pad",
+            "url": "./pad"
+        },
+        {
+            "label": "replace",
+            "url": "./replace"
+        },
+        {
+            "label": "split",
+            "url": "./split"
+        },
+        {
+            "label": "strip",
+            "url": "./strip"
+        },
+        {
+            "label": "strrep",
+            "url": "./strrep"
+        },
+        {
+            "label": "strtrim",
+            "url": "./strtrim"
+        },
+        {
+            "label": "upper",
+            "url": "./upper"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/transform/strcat.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/transform/strcat.rs"
+    },
+    "gpu_residency": "No. String manipulation runs on the CPU. If intermediate values are on the GPU, RunMat gathers them automatically so you can call `strcat` without extra residency management.",
+    "gpu_behavior": [
+        "RunMat currently performs text concatenation on the CPU. When any operand resides on the GPU, the runtime gathers it to host memory before applying MATLAB-compatible trimming and concatenation rules. Providers do not need to implement device kernels for this builtin today."
+    ],
+    "key": "strcat",
+    "slug": "strcat",
+    "categoryPath": [
+        "strings",
+        "transform"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=strcat.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strcat.js","sourceRoot":"","sources":["../../../src/generated/builtins/strcat.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,QAAQ;QACR,sBAAsB;QACtB,kBAAkB;QAClB,aAAa;QACb,iBAAiB;KAClB;IACD,SAAS,EAAE,8FAA8F;IACzG,YAAY,EAAE;QACZ,uDAAuD;KACxD;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,gHAAgH;KAC1H;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,6CAA6C;QACrD,aAAa,EAAE,sFAAsF;KACtG;IACD,aAAa,EAAE,oOAAoO;IACnP,WAAW,EAAE;QACX,oIAAoI;QACpI,4LAA4L;QAC5L,wJAAwJ;QACxJ,0JAA0J;QAC1J,kJAAkJ;QAClJ,sHAAsH;KACvH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,qCAAqC;YAC9C,QAAQ,EAAE,uBAAuB;SAClC;QACD;YACE,aAAa,EAAE,iDAAiD;YAChE,OAAO,EAAE,2FAA2F;YACpG,QAAQ,EAAE,6FAA6F;SACxG;QACD;YACE,aAAa,EAAE,6DAA6D;YAC5E,OAAO,EAAE,4FAA4F;YACrG,QAAQ,EAAE,qEAAqE;SAChF;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,uHAAuH;YAChI,QAAQ,EAAE,2FAA2F;SACtG;QACD;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,uEAAuE;YAChF,QAAQ,EAAE,kDAAkD;SAC7D;QACD;YACE,aAAa,EAAE,8DAA8D;YAC7E,OAAO,EAAE,4FAA4F;YACrG,QAAQ,EAAE,kGAAkG;SAC7G;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,yOAAyO;SACpP;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,+IAA+I;SAC1J;QACD;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,8JAA8J;SACzK;QACD;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,oMAAoM;SAC/M;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,sKAAsK;SACjL;QACD;YACE,UAAU,EAAE,+BAA+B;YAC3C,QAAQ,EAAE,4KAA4K;SACvL;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;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,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,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,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,kEAAkE;QAC3E,KAAK,EAAE,+GAA+G;KACvH;IACD,eAAe,EAAE,gLAAgL;IACjM,cAAc,EAAE;QACd,mRAAmR;KACpR;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,cAAc,EAAE;QACd,SAAS;QACT,WAAW;KACZ;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/strcmp.js

@@ -0,0 +1,169 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "strcmp",
+    "category": "strings/core",
+    "keywords": [
+        "strcmp",
+        "string compare",
+        "text equality",
+        "cell array",
+        "character vector"
+    ],
+    "summary": "Compare text inputs for exact equality with MATLAB-compatible implicit expansion across text types.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/strcmp.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "matlab",
+        "notes": "Executes on the CPU; GPU-resident inputs are gathered automatically so results match MATLAB behaviour."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::core::strcmp::tests",
+        "integration": "builtins::strings::core::strcmp::tests::strcmp_cell_array_scalar"
+    },
+    "description": "`strcmp(a, b)` returns logical `true` when two pieces of text match exactly and `false` otherwise. It accepts string arrays, character vectors/arrays, and cell arrays of character vectors, mirroring MATLAB semantics.",
+    "behaviors": [
+        "**Accepted text types**: Works with string scalars/arrays, character vectors or matrices created with `char`, and cell arrays of character vectors. Mixed combinations are converted automatically, matching MATLAB.",
+        "**Implicit expansion**: Scalar inputs expand to the shape of the other operand, producing element-wise comparisons for higher-dimensional arrays.",
+        "**Character arrays**: Rows are compared individually. The result is a column vector whose length equals the number of rows in the character array.",
+        "**Cell arrays**: Each cell is treated as a text scalar. Scalar cell arrays expand across the other operand before comparison.",
+        "**Missing strings**: String elements equal to `missing` compare unequal to everything, including other `missing` values.",
+        "**Result form**: A single logical scalar is returned for scalar comparisons; otherwise you receive a logical array using column-major MATLAB layout.",
+        "**Case sensitivity**: Matching is case-sensitive. Use `strcmpi` for case-insensitive comparisons."
+    ],
+    "examples": [
+        {
+            "description": "Compare Two Equal Strings",
+            "input": "tf = strcmp(\"RunMat\", \"RunMat\")",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "Compare String Array With Scalar Text",
+            "input": "names = [\"red\" \"green\" \"blue\"];\ntf = strcmp(names, \"green\")",
+            "output": "tf = 1×3 logical array\n   0   1   0"
+        },
+        {
+            "description": "Compare Character Array Rows",
+            "input": "labels = char(\"cat\", \"dog\", \"cat\");\ntf = strcmp(labels, \"cat\")",
+            "output": "tf = 3×1 logical array\n   1\n   0\n   1"
+        },
+        {
+            "description": "Compare Two Cell Arrays Of Character Vectors",
+            "input": "C1 = {'apple', 'pear', 'grape'};\nC2 = {'apple', 'peach', 'grape'};\ntf = strcmp(C1, C2)",
+            "output": "tf = 1×3 logical array\n   1   0   1"
+        },
+        {
+            "description": "Handle Missing Strings",
+            "input": "vals = [\"alpha\" missing];\ntf = strcmp(vals, \"alpha\")",
+            "output": "tf = 1×2 logical array\n   1   0"
+        },
+        {
+            "description": "Implicit Expansion With Column Vector Text",
+            "input": "patterns = char(\"north\", \"south\");\ntf = strcmp(patterns, [\"north\" \"east\"])",
+            "output": "tf = 2×2 logical array\n   1   0\n   0   0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What types can I pass to `strcmp`?",
+            "answer": "Use string arrays, character vectors/arrays, or cell arrays of character vectors. Mixed combinations are accepted and follow MATLAB's implicit expansion rules."
+        },
+        {
+            "question": "Does `strcmp` ignore letter case?",
+            "answer": "No. `strcmp` is case-sensitive. Use `strcmpi` for case-insensitive comparisons."
+        },
+        {
+            "question": "What happens when the inputs contain missing strings?",
+            "answer": "Missing string scalars compare unequal to every value (including other missing strings), so the result is `false`."
+        },
+        {
+            "question": "Can `strcmp` compare matrices of characters?",
+            "answer": "Yes. Character arrays compare row-by-row, returning a column vector whose entries tell you whether each row matches."
+        },
+        {
+            "question": "Does `strcmp` return numeric or logical results?",
+            "answer": "It returns logical results. Scalars become logical scalars (`Value::Bool`), while arrays are returned as logical arrays."
+        }
+    ],
+    "links": [
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "contains",
+            "url": "./contains"
+        },
+        {
+            "label": "startswith",
+            "url": "./startswith"
+        },
+        {
+            "label": "strlength",
+            "url": "./strlength"
+        },
+        {
+            "label": "compose",
+            "url": "./compose"
+        },
+        {
+            "label": "num2str",
+            "url": "./num2str"
+        },
+        {
+            "label": "sprintf",
+            "url": "./sprintf"
+        },
+        {
+            "label": "str2double",
+            "url": "./str2double"
+        },
+        {
+            "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/strcmp.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/core/strcmp.rs"
+    },
+    "gpu_residency": "You normally do **not** need to call `gpuArray`. If you do, RunMat gathers the operands before computing `strcmp` so the output matches MATLAB. The result always lives on the host because this builtin inspects text data.",
+    "gpu_behavior": [
+        "`strcmp` is registered as an acceleration sink. When either input resides on the GPU, RunMat gathers both operands back to host memory before comparing them so the results match MATLAB exactly. Providers do not need to implement custom kernels, and the logical result is always returned on the CPU."
+    ],
+    "key": "strcmp",
+    "slug": "strcmp",
+    "categoryPath": [
+        "strings",
+        "core"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=strcmp.js.map

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

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

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

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

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

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

@@ -0,0 +1,181 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "strcmpi",
+    "category": "strings/core",
+    "keywords": [
+        "strcmpi",
+        "case insensitive compare",
+        "string compare",
+        "text equality",
+        "cell array"
+    ],
+    "summary": "Compare text inputs for equality without considering letter case, matching MATLAB's `strcmpi` semantics.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/strcmpi.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "matlab",
+        "notes": "Runs on the host; GPU inputs are gathered automatically before comparison so results match MATLAB exactly."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::core::strcmpi::tests",
+        "integration": "builtins::strings::core::strcmpi::tests::strcmpi_cell_array_scalar_casefold"
+    },
+    "description": "`strcmpi(a, b)` compares text values without considering letter case. It returns logical `true` when inputs match case-insensitively and `false` otherwise. Supported text types mirror MATLAB: string scalars/arrays, character vectors and arrays, and cell arrays filled with character vectors.",
+    "behaviors": [
+        "**Case-insensitive**: Letter case is ignored. `\"RunMat\"`, `\"runmat\"`, and `\"RUNMAT\"` all compare equal.",
+        "**Accepted text types**: Works with string arrays, character vectors or matrices, and cell arrays of character vectors. Mixed combinations are normalised automatically.",
+        "**Implicit expansion**: Scalar operands expand against array operands so element-wise comparisons follow MATLAB broadcasting rules.",
+        "**Character arrays**: Rows are compared individually. Results are column vectors whose length equals the number of rows in the character array.",
+        "**Cell arrays**: Each cell is treated as a text scalar. Scalar cells expand across the other operand before comparison.",
+        "**Missing strings**: Elements whose value is `missing` (`\"<missing>\"`) always compare unequal, even to other missing values, matching MATLAB.",
+        "**Result form**: Scalar comparisons return logical scalars. Otherwise the result is a logical array that matches the broadcast shape."
+    ],
+    "examples": [
+        {
+            "description": "Compare Two Strings Ignoring Case",
+            "input": "tf = strcmpi(\"RunMat\", \"runmat\")",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "Find Case-Insensitive Matches Inside a String Array",
+            "input": "colors = [\"Red\" \"GREEN\" \"blue\"];\nmask = strcmpi(colors, \"green\")",
+            "output": "mask = 1×3 logical array\n   0   1   0"
+        },
+        {
+            "description": "Compare Character Array Rows Without Case Sensitivity",
+            "input": "animals = char(\"Cat\", \"DOG\", \"cat\");\ntf = strcmpi(animals, \"cAt\")",
+            "output": "tf = 3×1 logical array\n   1\n   0\n   1"
+        },
+        {
+            "description": "Compare Cell Arrays Of Character Vectors Case-Insensitively",
+            "input": "C1 = {'north', 'East', 'SOUTH'};\nC2 = {'NORTH', 'east', 'west'};\ntf = strcmpi(C1, C2)",
+            "output": "tf = 1×3 logical array\n   1   1   0"
+        },
+        {
+            "description": "Broadcast A String Scalar Against A Character Matrix",
+            "input": "patterns = char(\"alpha\", \"BETA\");\ntf = strcmpi(patterns, [\"ALPHA\" \"beta\"])",
+            "output": "tf = 2×2 logical array\n   1   0\n   0   1"
+        },
+        {
+            "description": "Handle Missing Strings In Case-Insensitive Comparisons",
+            "input": "values = [\"Active\" missing];\nmask = strcmpi(values, \"active\")",
+            "output": "mask = 1×2 logical array\n   1   0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `strcmpi` support string arrays, character arrays, and cell arrays?",
+            "answer": "Yes. All MATLAB-supported text containers are accepted, and mixed combinations are handled automatically with implicit expansion."
+        },
+        {
+            "question": "Is whitespace significant when comparing character arrays?",
+            "answer": "Yes. Trailing spaces or different lengths make rows unequal, just like `strcmp`. Use `strtrim` or `strip` if you need to ignore whitespace."
+        },
+        {
+            "question": "Do missing strings compare equal?",
+            "answer": "No. The `missing` sentinel compares unequal to all values, including another missing string scalar."
+        },
+        {
+            "question": "Can I compare complex numbers or numeric arrays with `strcmpi`?",
+            "answer": "No. Both arguments must contain text. Numeric inputs produce a descriptive MATLAB-style error."
+        },
+        {
+            "question": "How are GPU inputs handled?",
+            "answer": "They are gathered to the CPU automatically before comparison. Providers do not need to implement additional kernels for `strcmpi`."
+        },
+        {
+            "question": "What is returned when both inputs are scalars?",
+            "answer": "A logical scalar is returned (`true` or `false`). For non-scalar shapes, a logical array that mirrors the broadcast dimensions is produced."
+        }
+    ],
+    "links": [
+        {
+            "label": "strcmp",
+            "url": "./strcmp"
+        },
+        {
+            "label": "contains",
+            "url": "./contains"
+        },
+        {
+            "label": "startswith",
+            "url": "./startswith"
+        },
+        {
+            "label": "endswith",
+            "url": "./endswith"
+        },
+        {
+            "label": "strip",
+            "url": "./strip"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "compose",
+            "url": "./compose"
+        },
+        {
+            "label": "num2str",
+            "url": "./num2str"
+        },
+        {
+            "label": "sprintf",
+            "url": "./sprintf"
+        },
+        {
+            "label": "str2double",
+            "url": "./str2double"
+        },
+        {
+            "label": "string.empty",
+            "url": "./string.empty"
+        },
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "strings",
+            "url": "./strings"
+        },
+        {
+            "label": "strlength",
+            "url": "./strlength"
+        },
+        {
+            "label": "strncmp",
+            "url": "./strncmp"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/core/strcmpi.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/core/strcmpi.rs"
+    },
+    "gpu_residency": "You rarely need to call `gpuArray` manually. When inputs already live on the GPU, RunMat gathers them before calling `strcmpi`, then returns a logical result on the host. This matches MATLAB’s behaviour while keeping the runtime simple. Subsequent GPU-aware code can explicitly transfer results back if needed.",
+    "gpu_behavior": [
+        "`strcmpi` is registered as an acceleration sink. When either operand resides on the GPU, RunMat gathers both to host memory before comparing them. This keeps behaviour identical to MATLAB and avoids requiring backend-specific kernels. The logical result is produced on the CPU and never remains GPU-resident."
+    ],
+    "key": "strcmpi",
+    "slug": "strcmpi",
+    "categoryPath": [
+        "strings",
+        "core"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=strcmpi.js.map

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

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

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

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

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

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