runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/regexprep.js

@@ -0,0 +1,139 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "regexprep",
+    "category": "strings/regex",
+    "keywords": [
+        "regexprep",
+        "regular expression",
+        "replace",
+        "substitute",
+        "regex"
+    ],
+    "summary": "Perform MATLAB-compatible regular expression replacements on character vectors, string arrays, or cell arrays.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/regexprep.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs on the CPU. Inputs resident on the GPU are gathered before evaluation, and results remain on the host."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::regex::regexprep::tests",
+        "integration": "builtins::strings::regex::regexprep::tests::regexprep_elementwise_arrays"
+    },
+    "description": "`regexprep(str, pattern, replacement)` searches `str` for regular expression matches and replaces each match with the specified replacement text. Inputs can be character vectors, string scalars, string arrays, or cell arrays of text, and the results honour MATLAB's container semantics.",
+    "behaviors": [
+        "With scalar text inputs, the result is a scalar of the same kind (`char` inputs stay `char`, string scalars stay string scalars).",
+        "String arrays and cell arrays are processed element-wise and produce containers with matching shapes. When patterns and replacements are provided as arrays of the same size, they are paired element-by-element; otherwise, scalar patterns/replacements broadcast to every element.",
+        "Cell or string arrays of patterns apply sequentially: each `(pattern, replacement)` pair is applied in order to every element.",
+        "The `'once'` flag limits each element to the first match. `'emptymatch','remove'` (default) skips zero-length matches, while `'emptymatch','allow'` lets them participate.",
+        "`'ignorecase'` and `'matchcase'` control case sensitivity. `'lineanchors'`, `'dotall'`, and `'dotExceptNewline'` toggle multiline and dot behaviours in the same way as `regexp`.",
+        "`'preservecase'` adjusts the replacement text so the case pattern of the first match (all upper, all lower, or title case) is preserved."
+    ],
+    "examples": [
+        {
+            "description": "Replacing vowels in a character vector",
+            "input": "clean = regexprep('abracadabra', '[aeiou]', 'X')",
+            "output": "clean =\n    'XbrXcXdXbrX'"
+        },
+        {
+            "description": "Applying multiple pattern/replacement pairs sequentially",
+            "input": "result = regexprep(\"Color: red\", {'Color', 'red'}, {'Shade', 'blue'})",
+            "output": "result = \"Shade: blue\""
+        },
+        {
+            "description": "Performing case-insensitive replacements",
+            "input": "names = regexprep([\"Alpha\"; \"beta\"; \"GaMmA\"], 'a', '_', 'ignorecase')",
+            "output": "names =\n  3×1 string array\n    \"_lph_\"\n    \"bet_\"\n    \"G__mM_\""
+        },
+        {
+            "description": "Preserving case of the original match",
+            "input": "words = regexprep('MATLAB and matlab', 'matlab', 'runmat', 'preservecase')",
+            "output": "words =\n    'RUNMAT and runmat'"
+        },
+        {
+            "description": "Limiting replacements to the first match with `'once'`",
+            "input": "out = regexprep(\"abababa\", 'ba', 'XY', 'once')",
+            "output": "out = \"aXYbaba\""
+        },
+        {
+            "description": "Using element-wise patterns for a string array",
+            "input": "expr = [\"foo\", \"bar\"];\npat = [\"f\", \"ar\"];\nrep = [\"F\", \"AR\"];\nexact = regexprep(expr, pat, rep)",
+            "output": "exact = 1×2 string\n    \"Foo\"    \"bAR\""
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How are container outputs shaped?",
+            "answer": "Outputs mirror the input container. Character vectors return character vectors, string arrays return string arrays with the same size, and cell arrays return cell arrays with matching shape."
+        },
+        {
+            "question": "Can I supply multiple patterns at once?",
+            "answer": "Yes. Provide `pattern` and `replacement` as equally-sized cell or string arrays. Each pair is applied sequentially to every element, mirroring MATLAB's behaviour."
+        },
+        {
+            "question": "What if my replacement needs capture-group text?",
+            "answer": "Use `$1`, `$2`, … for numbered groups or `${name}` for named groups inside the replacement text. These tokens expand to the corresponding captured substrings."
+        },
+        {
+            "question": "Does `regexprep` support case-insensitive matching?",
+            "answer": "Yes. Pass the `'ignorecase'` option (or `'matchcase'` to revert). You can also request multiline anchors or dot behaviour changes with `'lineanchors'`, `'dotall'`, or `'dotExceptNewline'`."
+        },
+        {
+            "question": "What does `'preservecase'` do?",
+            "answer": "When enabled, `regexprep` inspects the alphabetic characters in the matched text. If they are all uppercase, lowercase, or title-cased, the replacement text is adjusted to match that style."
+        },
+        {
+            "question": "Does `regexprep` execute on the GPU?",
+            "answer": "No. All matching and replacement runs on the CPU. GPU inputs are downloaded automatically, but the results remain in host memory."
+        }
+    ],
+    "links": [
+        {
+            "label": "regexp",
+            "url": "./regexp"
+        },
+        {
+            "label": "regexpi",
+            "url": "./regexpi"
+        },
+        {
+            "label": "strrep",
+            "url": "./strrep"
+        },
+        {
+            "label": "replace",
+            "url": "./replace"
+        },
+        {
+            "label": "contains",
+            "url": "./contains"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/regex/regexprep.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/regex/regexprep.rs"
+    },
+    "gpu_behavior": [
+        "`regexprep` executes entirely on the CPU. When the subject, pattern, or replacement values originate from GPU-resident arrays, RunMat gathers them to host memory before performing the replacements. Results remain on the host; callers that need GPU residency should explicitly move the values back afterwards (e.g. with `gpuArray`)."
+    ],
+    "key": "regexprep",
+    "slug": "regexprep",
+    "categoryPath": [
+        "strings",
+        "regex"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=regexprep.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"regexprep.js","sourceRoot":"","sources":["../../../src/generated/builtins/regexprep.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,WAAW;IACpB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,WAAW;QACX,oBAAoB;QACpB,SAAS;QACT,YAAY;QACZ,OAAO;KACR;IACD,SAAS,EAAE,gHAAgH;IAC3H,YAAY,EAAE;QACZ,0DAA0D;KAC3D;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6GAA6G;KACvH;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,0EAA0E;KAC1F;IACD,aAAa,EAAE,gSAAgS;IAC/S,WAAW,EAAE;QACX,mIAAmI;QACnI,uRAAuR;QACvR,gIAAgI;QAChI,4KAA4K;QAC5K,mLAAmL;QACnL,0IAA0I;KAC3I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,kDAAkD;YAC3D,QAAQ,EAAE,4BAA4B;SACvC;QACD;YACE,aAAa,EAAE,0DAA0D;YACzE,OAAO,EAAE,yEAAyE;YAClF,QAAQ,EAAE,0BAA0B;SACrC;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,6EAA6E;YACtF,QAAQ,EAAE,0EAA0E;SACrF;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,4EAA4E;YACrF,QAAQ,EAAE,kCAAkC;SAC7C;QACD;YACE,aAAa,EAAE,wDAAwD;YACvE,OAAO,EAAE,kDAAkD;YAC3D,QAAQ,EAAE,mBAAmB;SAC9B;QACD;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,+GAA+G;YACxH,QAAQ,EAAE,4CAA4C;SACvD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,gMAAgM;SAC3M;QACD;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,oKAAoK;SAC/K;QACD;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,gKAAgK;SAC3K;QACD;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,8LAA8L;SACzM;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,+LAA+L;SAC1M;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,mIAAmI;SAC9I;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,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,cAAc,EAAE;QACd,6UAA6U;KAC9U;IACD,KAAK,EAAE,WAAW;IAClB,MAAM,EAAE,WAAW;IACnB,cAAc,EAAE;QACd,SAAS;QACT,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/rem.js

@@ -0,0 +1,163 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "rem",
+    "category": "math/rounding",
+    "keywords": [
+        "rem",
+        "remainder",
+        "truncate",
+        "rounding",
+        "gpu"
+    ],
+    "summary": "Compute the MATLAB remainder a - b .* fix(./b) for scalars, matrices, N-D tensors, and complex values.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/rem.html"
+    ],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Composed from elem_div → unary_fix → elem_mul → elem_sub when GPU operands share a shape; otherwise RunMat gathers to the host."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::rounding::rem::tests",
+        "integration": "builtins::math::rounding::rem::tests::rem_gpu_pair_roundtrip"
+    },
+    "description": "`C = rem(A, B)` returns the remainder after division with the quotient rounded toward zero: `C = A - B .* fix(A ./ B)`. The result has the same sign as the dividend (`A`) and a magnitude strictly smaller than `abs(B)` when `B` is finite.",
+    "behaviors": [
+        "Supports scalars, vectors, matrices, and higher-dimensional tensors with MATLAB-style implicit expansion (broadcasting).",
+        "Returns `NaN` when the divisor is zero or when the dividend is non-finite while the divisor is finite.",
+        "Infinite divisors leave finite dividends unchanged (because the quotient is zero).",
+        "Logical and integer inputs promote to double precision; character arrays operate on their Unicode code points.",
+        "Complex inputs follow MATLAB semantics: `rem(z, w) = z - w .* fix(z ./ w)` with `fix` applied component-wise to the complex quotient.",
+        "Empty inputs propagate emptiness while preserving shape."
+    ],
+    "examples": [
+        {
+            "description": "Remainder of positive integers",
+            "input": "r = rem(17, 5)",
+            "output": "r = 2"
+        },
+        {
+            "description": "Remainder keeps dividend sign for negatives",
+            "input": "values = [-7 -3 4 9];\nremainders = rem(values, 4)",
+            "output": "remainders = [-3 -3 0 1]"
+        },
+        {
+            "description": "Remainder with a negative divisor",
+            "input": "r = rem(7, -4)",
+            "output": "r = 3"
+        },
+        {
+            "description": "Applying remainder across arrays with broadcasting",
+            "input": "A = [4.5 7.1; -2.3 0.4];\nB = rem(A, 2)",
+            "output": "B = [0.5 1.1;\n     -0.3 0.4]"
+        },
+        {
+            "description": "Complex remainders follow fix-based quotient",
+            "input": "z = [3 + 4i, -2 + 5i];\nw = 2 + 1i;\nres = rem(z, w)",
+            "output": "res = [0.0 + 0.0i  0.0 + 1.0i]"
+        },
+        {
+            "description": "Keeping `rem` on the GPU when kernels are available",
+            "input": "G = gpuArray(-5:5);\nH = rem(G, 4);\nhostCopy = gather(H)",
+            "output": "hostCopy = [-1 0 -3 -2 -1 0 1 2 3 0 1]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How is `rem` different from `mod`?",
+            "answer": "`rem` rounds the quotient with `fix`, so the remainder inherits the dividend's sign. `mod` rounds with `floor`, which ties the remainder to the divisor's sign. Both functions share broadcasting rules, but they differ whenever negative values are involved."
+        },
+        {
+            "question": "What happens when the divisor is zero?",
+            "answer": "MATLAB defines `rem(A, 0)` as `NaN` (and `NaN + NaNi` for complex operands). RunMat mirrors this behaviour so error handling and edge cases match scripts written for MATLAB."
+        },
+        {
+            "question": "Does `rem` support infinite inputs?",
+            "answer": "Yes. When `B` is infinite and `A` is finite, the quotient truncates to zero and the result is exactly `A`. If the dividend is infinite while the divisor is finite, the remainder is `NaN`, preserving MATLAB's rules for indeterminate operations."
+        },
+        {
+            "question": "Can `rem` operate on complex numbers?",
+            "answer": "Absolutely. Both operands may be complex; RunMat computes `rem(z, w)` as `z - w .* fix(z ./ w)`, applying `fix` to the real and imaginary components independently so the result matches MATLAB's complex arithmetic."
+        },
+        {
+            "question": "Does `rem` change integer or logical inputs?",
+            "answer": "Internally, inputs promote to double precision before the remainder is computed. The result is returned as doubles, aligning with MATLAB's numeric tower while still supporting logical, integer, and character array arguments."
+        },
+        {
+            "question": "Will `rem` stay on the GPU?",
+            "answer": "It stays on-device when the provider implements `elem_div`, `unary_fix`, `elem_mul`, and `elem_sub`; fusion-aware planners can keep intermediates resident for downstream kernels. Otherwise the runtime gathers the operands, executes the CPU fallback, and returns a host tensor so correctness is unaffected."
+        },
+        {
+            "question": "What does rem do in MATLAB?",
+            "answer": "`rem(a, b)` returns the remainder after dividing `a` by `b`. The result has the same sign as the dividend `a`. For example, `rem(7, 3)` returns `1` and `rem(-7, 3)` returns `-1`."
+        },
+        {
+            "question": "What is the difference between rem and mod in MATLAB?",
+            "answer": "Both compute remainders, but `rem` preserves the sign of the dividend while `mod` preserves the sign of the divisor. `rem(-7, 3)` returns `-1`, but `mod(-7, 3)` returns `2`."
+        },
+        {
+            "question": "Does rem support GPU arrays in RunMat?",
+            "answer": "Yes. `rem` runs on the GPU with elementwise fusion support, allowing it to be combined with other operations for efficient computation."
+        }
+    ],
+    "links": [
+        {
+            "label": "mod",
+            "url": "./mod"
+        },
+        {
+            "label": "fix",
+            "url": "./fix"
+        },
+        {
+            "label": "floor",
+            "url": "./floor"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "ceil",
+            "url": "./ceil"
+        },
+        {
+            "label": "round",
+            "url": "./round"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/rounding/rem.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/rounding/rem.rs"
+    },
+    "gpu_residency": "Typically no. The native auto-offload planner keeps tensors on the GPU whenever the provider implements the chained kernels described above or when `rem` participates in a larger fused expression. If any hook is missing—or when inputs start on the host—RunMat gathers automatically, executes the CPU fallback, and returns the result. You can still call `gpuArray` and `gather` explicitly for compatibility with MathWorks MATLAB scripts or to control residency manually.",
+    "gpu_behavior": [
+        "When both operands are GPU tensors with identical shapes and the active provider exposes `elem_div`, `unary_fix`, `elem_mul`, and `elem_sub`, RunMat evaluates `rem` fully on the device by chaining those kernels. Intermediate buffers stay device-side, fusion-aware planners can inline the sequence, and the final remainder handle remains on the GPU for downstream work. If residency is mixed, shapes differ, or any hook is unavailable, RunMat automatically gathers to the host, executes the MATLAB-compatible fallback, and returns a CPU tensor while preserving observable semantics."
+    ],
+    "key": "rem",
+    "slug": "rem",
+    "categoryPath": [
+        "math",
+        "rounding"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=rem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rem.js","sourceRoot":"","sources":["../../../src/generated/builtins/rem.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,KAAK;IACd,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,KAAK;QACL,WAAW;QACX,UAAU;QACV,UAAU;QACV,KAAK;KACN;IACD,SAAS,EAAE,wGAAwG;IACnH,YAAY,EAAE;QACZ,oDAAoD;KACrD;IACD,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,iIAAiI;KAC3I;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,sCAAsC;QAC9C,aAAa,EAAE,8DAA8D;KAC9E;IACD,aAAa,EAAE,+OAA+O;IAC9P,WAAW,EAAE;QACX,0HAA0H;QAC1H,wGAAwG;QACxG,oFAAoF;QACpF,gHAAgH;QAChH,uIAAuI;QACvI,0DAA0D;KAC3D;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,gBAAgB;YACzB,QAAQ,EAAE,OAAO;SAClB;QACD;YACE,aAAa,EAAE,6CAA6C;YAC5D,OAAO,EAAE,oDAAoD;YAC7D,QAAQ,EAAE,0BAA0B;SACrC;QACD;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,gBAAgB;YACzB,QAAQ,EAAE,OAAO;SAClB;QACD;YACE,aAAa,EAAE,oDAAoD;YACnE,OAAO,EAAE,yCAAyC;YAClD,QAAQ,EAAE,+BAA+B;SAC1C;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,sDAAsD;YAC/D,QAAQ,EAAE,gCAAgC;SAC3C;QACD;YACE,aAAa,EAAE,qDAAqD;YACpE,OAAO,EAAE,2DAA2D;YACpE,QAAQ,EAAE,wCAAwC;SACnD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,iQAAiQ;SAC5Q;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,+KAA+K;SAC1L;QACD;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,qPAAqP;SAChQ;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,uNAAuN;SAClO;QACD;YACE,UAAU,EAAE,8CAA8C;YAC1D,QAAQ,EAAE,kOAAkO;SAC7O;QACD;YACE,UAAU,EAAE,6BAA6B;YACzC,QAAQ,EAAE,mTAAmT;SAC9T;QACD;YACE,UAAU,EAAE,6BAA6B;YACzC,QAAQ,EAAE,oLAAoL;SAC/L;QACD;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,+KAA+K;SAC1L;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,yIAAyI;SACpJ;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,eAAe,EAAE,udAAud;IACxe,cAAc,EAAE;QACd,ukBAAukB;KACxkB;IACD,KAAK,EAAE,KAAK;IACZ,MAAM,EAAE,KAAK;IACb,cAAc,EAAE;QACd,MAAM;QACN,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/replace.js

@@ -0,0 +1,195 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "replace",
+    "category": "strings/transform",
+    "keywords": [
+        "replace",
+        "substring replace",
+        "string replace",
+        "strrep",
+        "text replace",
+        "character array replace"
+    ],
+    "summary": "Replace substring occurrences in strings, character arrays, and cell arrays.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/replace.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs on the CPU. RunMat gathers GPU-resident text before performing replacements."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::transform::replace::tests",
+        "integration": "builtins::strings::transform::replace::tests::replace_cell_array_mixed_content"
+    },
+    "description": "`replace(str, old, new)` substitutes every occurrence of `old` found in `str` with `new`. The builtin accepts string scalars, string arrays, character arrays, and cell arrays of character vectors or strings, matching MATLAB semantics. Multiple search terms are supported—each matched entry is replaced by its corresponding replacement text.",
+    "behaviors": [
+        "String scalars remain strings. Missing string scalars (`<missing>`) propagate unchanged.",
+        "String arrays are processed element wise while preserving shape.",
+        "Character arrays are handled row by row. Rows expand or shrink as needed and are padded with spaces so the result remains a rectangular char array, just like MATLAB.",
+        "Cell arrays must contain string scalars or character vectors. The result is a cell array with the same size and element types mirrored after replacement.",
+        "The `old` and `new` inputs can be string scalars, string arrays, character arrays, or cell arrays of character vectors / strings. `new` must be a scalar or match the number of search terms in `old`.",
+        "Non-text inputs (numeric, logical, structs, GPU tensors, etc.) produce MATLAB-compatible errors."
+    ],
+    "examples": [
+        {
+            "description": "Replace all instances of a word in a string",
+            "input": "txt = \"RunMat accelerates MATLAB code\";\nresult = replace(txt, \"RunMat\", \"RunMat Accelerate\")",
+            "output": "result = \"RunMat Accelerate accelerates MATLAB code\""
+        },
+        {
+            "description": "Replace multiple terms in a string array",
+            "input": "labels = [\"GPU pipeline\"; \"CPU pipeline\"];\nresult = replace(labels, [\"GPU\", \"CPU\"], [\"Device\", \"Host\"])",
+            "output": "result = 2×1 string\n    \"Device pipeline\"\n    \"Host pipeline\""
+        },
+        {
+            "description": "Replace substrings in a character array while preserving padding",
+            "input": "chars = char(\"alpha\", \"beta \");\nout = replace(chars, \"a\", \"A\")",
+            "output": "out =\n\n  2×5 char array\n\n    'AlphA'\n    'betA '"
+        },
+        {
+            "description": "Replace text within a cell array of character vectors",
+            "input": "C = {'Kernel Fusion', 'GPU Planner'};\nupdated = replace(C, {'Kernel', 'GPU'}, {'Shader', 'Device'})",
+            "output": "updated = 1×2 cell array\n    {'Shader Fusion'}    {'Device Planner'}"
+        },
+        {
+            "description": "Remove substrings by replacing with empty text",
+            "input": "paths = [\"runmat/bin\", \"runmat/lib\"];\nclean = replace(paths, \"runmat/\", \"\")",
+            "output": "clean = 1×2 string\n    \"bin\"    \"lib\""
+        },
+        {
+            "description": "Replace using scalar replacement for multiple search terms",
+            "input": "message = \"OpenCL or CUDA or Vulkan\";\nunified = replace(message, [\"OpenCL\", \"CUDA\", \"Vulkan\"], \"GPU backend\")",
+            "output": "unified = \"GPU backend or GPU backend or GPU backend\""
+        },
+        {
+            "description": "Replace text stored inside a cell array of strings",
+            "input": "cells = { \"Snapshot\", \"Ignition Interpreter\" };\nrenamed = replace(cells, \" \", \"_\")",
+            "output": "renamed = 1×2 cell array\n    {\"Snapshot\"}    {\"Ignition_Interpreter\"}"
+        },
+        {
+            "description": "Preserve missing strings during replacement",
+            "input": "vals = [\"runmat\", \"<missing>\", \"accelerate\"];\nout = replace(vals, \"runmat\", \"RunMat\")",
+            "output": "out = 1×3 string\n    \"RunMat\"    <missing>    \"accelerate\""
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What sizes are allowed for `old` and `new` inputs?",
+            "answer": "`old` must contain at least one search term. `new` may be a scalar or contain the same number of elements as `old`. Otherwise, `replace` raises a size-mismatch error matching MATLAB behaviour."
+        },
+        {
+            "question": "Does `replace` modify the original input?",
+            "answer": "No. The builtin returns a new value with substitutions applied. The original inputs are left untouched."
+        },
+        {
+            "question": "How are character arrays padded after replacement?",
+            "answer": "Each row is expanded or truncated according to the longest resulting row. Shorter rows are padded with space characters so the output remains a proper char matrix."
+        },
+        {
+            "question": "How are missing strings handled?",
+            "answer": "Missing string scalars (`<missing>`) propagate unchanged. Replacements never convert a missing value into a non-missing string."
+        },
+        {
+            "question": "Can I replace with an empty string?",
+            "answer": "Yes. Provide `\"\"` (empty string) or `''` as the replacement to remove matched substrings entirely."
+        },
+        {
+            "question": "Does `replace` support overlapping matches?",
+            "answer": "Replacements are non-overlapping and proceed from left to right, matching MATLAB’s behaviour for `replace`."
+        },
+        {
+            "question": "How does `replace` behave with GPU data?",
+            "answer": "RunMat gathers GPU-resident inputs to host memory before performing replacements. The resulting value is returned on the host. Providers do not need to implement a GPU kernel for this builtin."
+        }
+    ],
+    "links": [
+        {
+            "label": "regexprep",
+            "url": "./regexprep"
+        },
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "strtrim",
+            "url": "./strtrim"
+        },
+        {
+            "label": "strip",
+            "url": "./strip"
+        },
+        {
+            "label": "erase",
+            "url": "./erase"
+        },
+        {
+            "label": "eraseBetween",
+            "url": "./erasebetween"
+        },
+        {
+            "label": "extractBetween",
+            "url": "./extractbetween"
+        },
+        {
+            "label": "join",
+            "url": "./join"
+        },
+        {
+            "label": "lower",
+            "url": "./lower"
+        },
+        {
+            "label": "pad",
+            "url": "./pad"
+        },
+        {
+            "label": "split",
+            "url": "./split"
+        },
+        {
+            "label": "strcat",
+            "url": "./strcat"
+        },
+        {
+            "label": "strrep",
+            "url": "./strrep"
+        },
+        {
+            "label": "upper",
+            "url": "./upper"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/transform/replace.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/transform/replace.rs"
+    },
+    "gpu_residency": "No. `replace` automatically gathers GPU inputs back to the host when necessary. Because it is marked with a gather-immediately residency policy, both inputs and outputs live on the CPU, so you never have to move text values manually. This mirrors MATLAB behaviour where string manipulation runs on the CPU.",
+    "gpu_behavior": [
+        "`replace` executes on the CPU. The builtin registers as an Accelerate sink, so the fusion planner never attempts to keep results on the device. When any argument is GPU-resident, RunMat gathers it to host memory before performing replacements. Providers do not need special kernels for this builtin, and GPU-resident results are returned on the host."
+    ],
+    "key": "replace",
+    "slug": "replace",
+    "categoryPath": [
+        "strings",
+        "transform"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=replace.js.map

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

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

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

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

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

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