runmat 0.3.5 → 0.4.0

package/dist/generated/builtins/std.js

@@ -0,0 +1,200 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "std",
+    "category": "math/reduction",
+    "keywords": [
+        "std",
+        "standard deviation",
+        "statistics",
+        "gpu",
+        "omitnan",
+        "all",
+        "like",
+        "native"
+    ],
+    "summary": "Standard deviation of scalars, vectors, matrices, or N-D tensors with MATLAB-compatible options.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": true,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Falls back to host when 'omitnan' is requested or the provider lacks std reductions."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::reduction::std::tests",
+        "integration": "builtins::math::reduction::std::tests::std_gpu_provider_roundtrip",
+        "gpu": "builtins::math::reduction::std::tests::std_wgpu_dim1_sample_matches_cpu"
+    },
+    "description": "`std(x)` measures the spread of the elements in `x`. By default RunMat matches MATLAB’s sample definition (dividing by `n-1`) and works along the first non-singleton dimension.",
+    "behaviors": [
+        "`std(X)` on an `m × n` matrix returns a `1 × n` row vector with the sample standard deviation of each column.",
+        "`std(X, 1)` switches to population normalisation (`n` in the denominator). Use `std(X, 0)` or `std(X, [])` to keep the default sample behaviour.",
+        "`std(X, flag, dim)` lets you pick both the normalisation (`flag = 0` sample, `1` population, or `[]`) and the dimension to reduce. `std(X, flag, 'all')` collapses every dimension, while `std(X, flag, vecdim)` accepts a dimension vector such as `[1 3]` and reduces all listed axes in a single call. Multi-axis reductions execute on the host today when the active GPU provider cannot fuse them.",
+        "Strings like `'omitnan'` and `'includenan'` decide whether `NaN` values are skipped or propagated.",
+        "Optional out-type arguments (`'double'`, `'default'`, `'native'`, or `'like', prototype`) mirror MATLAB behaviour. `'native'` rounds scalar integer results back to their original class; `'like'` mirrors both the numeric class and device residency of `prototype` (complex prototypes yield complex outputs with zero imaginary parts).",
+        "Logical inputs are promoted to double precision before reduction so that results follow MATLAB’s numeric rules.",
+        "Empty slices return `NaN` with MATLAB-compatible shapes. Scalars return `0`, regardless of the normalisation mode.",
+        "Dimensions greater than `ndims(X)` leave the input untouched.",
+        "Weighted standard deviations (`flag` as a vector) are not implemented yet; RunMat reports a descriptive error when they are requested.\n\nComplex tensors are not currently supported; convert them to real magnitudes manually before calling `std`."
+    ],
+    "examples": [
+        {
+            "description": "Sample standard deviation of a vector",
+            "input": "x = [1 2 3 4 5];\ns = std(x);                 % uses flag = 0 (sample) by default",
+            "output": "s = 1.5811"
+        },
+        {
+            "description": "Population standard deviation of each column",
+            "input": "A = [1 3 5; 2 4 6];\nspop = std(A, 1);           % divide by n instead of n-1",
+            "output": "spop = [0.5 0.5 0.5]"
+        },
+        {
+            "description": "Collapsing every dimension at once",
+            "input": "B = reshape(1:12, [3 4]);\noverall = std(B, 0, 'all')",
+            "output": "overall = 3.6056"
+        },
+        {
+            "description": "Reducing across multiple dimensions",
+            "input": "C = cat(3, [1 2; 3 4], [5 6; 7 8]);\nsliceStd = std(C, [], [1 3]);   % keep columns, reduce rows & pages",
+            "output": "sliceStd = [2.5820 2.5820]"
+        },
+        {
+            "description": "Ignoring NaN values",
+            "input": "D = [1 NaN 3; 2 4 NaN];\nrowStd = std(D, 0, 2, 'omitnan')",
+            "output": "rowStd = [1.4142; 1.4142]"
+        },
+        {
+            "description": "Matching a prototype using `'like'`",
+            "input": "proto = gpuArray(single(42));\nG = gpuArray(rand(1024, 512));\nspread = std(G, 1, 'all', 'like', proto);\nanswer = gather(spread)"
+        },
+        {
+            "description": "Preserving default behaviour with an empty normalisation flag",
+            "input": "C = [1 2; 3 4];\nrowStd = std(C, [], 2)",
+            "output": "rowStd = [0.7071; 0.7071]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What values can I pass as the normalisation flag?",
+            "answer": "Use `0` (or `[]`) for the sample definition, `1` for population. RunMat rejects non-scalar weight vectors and reports that weighted standard deviations are not implemented yet."
+        },
+        {
+            "question": "How can I collapse multiple dimensions?",
+            "answer": "Pass a vector of dimensions such as `std(A, [], [1 3])`. You can also use `'all'` to collapse every dimension into a single scalar."
+        },
+        {
+            "question": "How do `'omitnan'` and `'includenan'` work?",
+            "answer": "`'omitnan'` skips NaN values; if every element in a slice is NaN the result is NaN. `'includenan'` (the default) propagates a single NaN to the output slice."
+        },
+        {
+            "question": "What do `'native'` and `'like'` do?",
+            "answer": "`'native'` rounds scalar results back to the input’s integer class (multi-element outputs stay in double precision for now), while `'double'`/`'default'` keep double precision. `'like', prototype` mirrors both the numeric class and the device residency of `prototype`, including GPU tensors; complex prototypes produce complex outputs with zero imaginary parts."
+        },
+        {
+            "question": "What happens if I request a dimension greater than `ndims(X)`?",
+            "answer": "RunMat returns the input unchanged so that MATLAB-compatible code relying on that behaviour continues to work."
+        },
+        {
+            "question": "Are complex inputs supported?",
+            "answer": "Not yet. RunMat currently requires real inputs for `std`. Convert complex data to magnitude or separate real/imaginary parts before calling the builtin."
+        }
+    ],
+    "links": [
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "median",
+            "url": "./median"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "all",
+            "url": "./all"
+        },
+        {
+            "label": "any",
+            "url": "./any"
+        },
+        {
+            "label": "cummax",
+            "url": "./cummax"
+        },
+        {
+            "label": "cummin",
+            "url": "./cummin"
+        },
+        {
+            "label": "cumprod",
+            "url": "./cumprod"
+        },
+        {
+            "label": "cumsum",
+            "url": "./cumsum"
+        },
+        {
+            "label": "diff",
+            "url": "./diff"
+        },
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "nnz",
+            "url": "./nnz"
+        },
+        {
+            "label": "prod",
+            "url": "./prod"
+        },
+        {
+            "label": "var",
+            "url": "./var"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/reduction/std.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/std.rs"
+    },
+    "gpu_residency": "Usually you do not need to call `gpuArray` manually. The fusion planner keeps tensors on the GPU across fused expressions and gathers them only when necessary. For explicit control or MATLAB compatibility, you can still call `gpuArray`/`gather` yourself.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active, device-resident tensors remain on the GPU whenever the provider implements the relevant hooks. Providers that expose `reduce_std_dim`/`reduce_std` execute the reduction in-place on the device; the default WGPU backend currently supports two-dimensional inputs, single-axis reductions, and `'includenan'` only. Whenever `'omitnan'`, multi-axis reductions, or unsupported shapes are requested, RunMat transparently gathers the data to the host, computes the result there, and then applies the requested output template (`'native'`, `'like'`) before returning."
+    ],
+    "key": "std",
+    "slug": "std",
+    "categoryPath": [
+        "math",
+        "reduction"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=std.js.map

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

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

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

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

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

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

package/dist/generated/builtins/stem.js

@@ -0,0 +1,96 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "stem",
+    "category": "plotting",
+    "keywords": [
+        "stem",
+        "stem plot",
+        "discrete signal plot",
+        "sequence visualization",
+        "matlab stem"
+    ],
+    "summary": "Create stem plots for discrete signals, sequence visualization, and MATLAB `stem` workflows.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`stem` has a dedicated GPU geometry path for stem segments and shared marker rendering for supported input combinations."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::stem::tests",
+        "integration": "runmat-plot/tests/renderer_tests.rs"
+    },
+    "description": "`stem` creates vertical stems from a baseline up to each sample value, making it a standard choice for discrete signals and sequence visualization. In RunMat it returns a first-class plot handle, supports MATLAB-style shorthand and explicit x/y forms, and uses the shared marker path so marker semantics stay aligned with the rest of the plotting system.",
+    "behaviors": [
+        "`stem(y)` uses implicit x-values `1:n`, while `stem(x, y)` uses explicit paired coordinates.",
+        "The returned value is a stem plot handle that works with `get` and `set`.",
+        "Baseline visibility, markers, fill behavior, display names, and line styling all flow through the shared plotting property model.",
+        "The plot remains subplot-local and composes naturally with legends and axes-local state.",
+        "GPU-backed geometry is used when plotting-compatible buffers are available, with marker rendering sharing the point/marker pipeline."
+    ],
+    "examples": [
+        {
+            "description": "Create a stem plot from y-values only",
+            "input": "stem([1 4 2 5 3]);"
+        },
+        {
+            "description": "Use explicit x-values and filled markers",
+            "input": "x = 0:5;\nh = stem(x, [0 1 0 2 0 3]);\nset(h, 'Filled', true, 'DisplayName', 'samples');\nlegend;"
+        },
+        {
+            "description": "Inspect a stem handle after plotting",
+            "input": "h = stem(1:5, [2 1 3 2 4]);\nget(h, 'Type')",
+            "output": "ans =\n    'stem'"
+        }
+    ],
+    "links": [
+        {
+            "label": "stairs",
+            "url": "./stairs"
+        },
+        {
+            "label": "errorbar",
+            "url": "./errorbar"
+        },
+        {
+            "label": "legend",
+            "url": "./legend"
+        },
+        {
+            "label": "get",
+            "url": "./get"
+        },
+        {
+            "label": "set",
+            "url": "./set"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/stem.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/stem.rs"
+    },
+    "gpu_residency": "`stem` preserves GPU residency when the direct stem packer path is available. Marker rendering stays on the shared marker path.",
+    "gpu_behavior": [
+        "Stem line geometry can be emitted directly from GPU buffers on the happy path.",
+        "Markers use the shared rendering path, which keeps style semantics aligned with the rest of the plotting stack."
+    ],
+    "key": "stem",
+    "slug": "stem",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=stem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stem.js","sourceRoot":"","sources":["../../../src/generated/builtins/stem.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,MAAM;QACN,WAAW;QACX,sBAAsB;QACtB,wBAAwB;QACxB,aAAa;KACd;IACD,SAAS,EAAE,8FAA8F;IACzG,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,QAAQ;YACR,QAAQ;SACT;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,0HAA0H;KACpI;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,iCAAiC;QACzC,aAAa,EAAE,qCAAqC;KACrD;IACD,aAAa,EAAE,oWAAoW;IACnX,WAAW,EAAE;QACX,8FAA8F;QAC9F,2EAA2E;QAC3E,mIAAmI;QACnI,0FAA0F;QAC1F,sIAAsI;KACvI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,oBAAoB;SAC9B;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,mGAAmG;SAC7G;QACD;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,6CAA6C;YACtD,QAAQ,EAAE,mBAAmB;SAC9B;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,eAAe,EAAE,iIAAiI;IAClJ,cAAc,EAAE;QACd,gFAAgF;QAChF,iHAAiH;KAClH;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/str2double.js

@@ -0,0 +1,185 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "str2double",
+    "category": "strings/core",
+    "keywords": [
+        "str2double",
+        "string to double",
+        "text conversion",
+        "numeric parsing",
+        "gpu"
+    ],
+    "summary": "Convert strings, character arrays, or cell arrays of text into double-precision numbers with MATLAB-compatible rules.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/str2double.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs on the CPU. When inputs reference GPU data, RunMat gathers them before parsing so results match MATLAB exactly."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::core::str2double::tests",
+        "integration": "builtins::strings::core::str2double::tests::str2double_cell_array_of_text"
+    },
+    "description": "`str2double` converts text representations of numbers into double-precision values. It accepts string scalars, string arrays, character vectors, character arrays, and cell arrays of character vectors. Each element is parsed independently; values that cannot be interpreted as real scalars become `NaN`.",
+    "behaviors": [
+        "Leading and trailing whitespace is ignored, as are padding spaces that MATLAB inserts in character arrays.",
+        "Text that contains a single finite real number returns that number. Text with additional characters, embedded operators, or multiple values results in `NaN`.",
+        "Scientific notation with `e`, `E`, `d`, or `D` exponents is supported (`\"1.2e3\"`, `\"4.5D-6\"`, etc.).",
+        "`\"Inf\"`, `\"Infinity\"`, and `\"NaN\"` (any letter case, with optional sign on `Inf`) map to IEEE special values.",
+        "Missing string scalars (displayed as `<missing>`) convert to `NaN`, matching MATLAB behaviour.",
+        "Character arrays return a column vector whose length equals the number of rows; cell arrays preserve their shape."
+    ],
+    "examples": [
+        {
+            "description": "Convert a string scalar into a double",
+            "input": "value = str2double(\"3.14159\")",
+            "output": "value = 3.14159"
+        },
+        {
+            "description": "Convert every element of a string array",
+            "input": "temps = [\"12.5\" \"19.8\" \"not-a-number\"];\ndata = str2double(temps)",
+            "output": "data = 1×3\n   12.5000   19.8000       NaN"
+        },
+        {
+            "description": "Parse scientific notation text",
+            "input": "result = str2double(\"6.022e23\")",
+            "output": "result = 6.0220e+23"
+        },
+        {
+            "description": "Handle engineering exponents written with `D`",
+            "input": "cap = str2double(\"4.7D-9\")",
+            "output": "cap = 4.7000e-09"
+        },
+        {
+            "description": "Convert a character array one row at a time",
+            "input": "chars = ['42   '; '  100'];\nnumbers = str2double(chars)",
+            "output": "numbers = 2×1\n    42\n   100"
+        },
+        {
+            "description": "Work with cell arrays of character vectors",
+            "input": "C = {'3.14', 'NaN', '-Inf'};\nvalues = str2double(C)",
+            "output": "values = 1×3\n    3.1400      NaN      -Inf"
+        },
+        {
+            "description": "Detect invalid numeric text",
+            "input": "status = str2double(\"error42\")",
+            "output": "status = NaN"
+        },
+        {
+            "description": "Recognise special values `Inf` and `NaN`",
+            "input": "special = str2double([\"Inf\"; \"-Infinity\"; \"NaN\"])",
+            "output": "special = 3×1\n     Inf\n    -Inf\n     NaN"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What input types does `str2double` accept?",
+            "answer": "String scalars, string arrays, character vectors, character arrays, and cell arrays of character vectors or string scalars are supported. Other types raise an error so that mismatched inputs are caught early."
+        },
+        {
+            "question": "How are invalid or empty strings handled?",
+            "answer": "Invalid text—including empty strings, whitespace-only rows, or strings with extra characters—converts to `NaN`. This matches MATLAB, which uses `NaN` as a sentinel for failed conversions."
+        },
+        {
+            "question": "Does `str2double` evaluate arithmetic expressions?",
+            "answer": "No. Unlike `str2num`, `str2double` never calls the evaluator. Text such as `\"1+2\"` or `\"sqrt(2)\"` yields `NaN` instead of executing the expression, keeping the builtin safe for untrusted input."
+        },
+        {
+            "question": "Can `str2double` parse complex numbers?",
+            "answer": "No. Complex text like `\"3+4i\"` returns `NaN`. Use `str2num` when you need MATLAB to interpret complex literals."
+        },
+        {
+            "question": "Are engineering exponents with `D` supported?",
+            "answer": "Yes. Exponents that use `d` or `D` are rewritten to `e` automatically, so `\"1.0D3\"` converts to `1000`."
+        },
+        {
+            "question": "How does `str2double` treat missing strings?",
+            "answer": "Missing strings produced with `string(missing)` display as `<missing>` and convert to `NaN`. You can detect them with `ismissing` before conversion if you need special handling."
+        },
+        {
+            "question": "Does locale affect parsing?",
+            "answer": "`str2double` honours digits, decimal points, and exponent letters only. Locale-specific grouping separators such as commas are not accepted, mirroring MATLAB's behaviour."
+        },
+        {
+            "question": "Will the result stay on the GPU when I pass gpuArray inputs?",
+            "answer": "No. The builtin gathers GPU-backed inputs to the host, parses them, and keeps the numeric result in host memory. Wrap the result with `gpuArray(...)` if you need to move it back to the device."
+        }
+    ],
+    "links": [
+        {
+            "label": "double",
+            "url": "./double"
+        },
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "compose",
+            "url": "./compose"
+        },
+        {
+            "label": "num2str",
+            "url": "./num2str"
+        },
+        {
+            "label": "sprintf",
+            "url": "./sprintf"
+        },
+        {
+            "label": "strcmp",
+            "url": "./strcmp"
+        },
+        {
+            "label": "strcmpi",
+            "url": "./strcmpi"
+        },
+        {
+            "label": "string.empty",
+            "url": "./string.empty"
+        },
+        {
+            "label": "strings",
+            "url": "./strings"
+        },
+        {
+            "label": "strlength",
+            "url": "./strlength"
+        },
+        {
+            "label": "strncmp",
+            "url": "./strncmp"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/core/str2double.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/core/str2double.rs"
+    },
+    "gpu_behavior": [
+        "`str2double` executes entirely on the CPU. If any argument is backed by a GPU buffer (for example, a cell array that still wraps GPU-resident character data), RunMat gathers the values first, parses the text on the host, and returns CPU-resident doubles. Providers do not need custom kernels for this builtin."
+    ],
+    "key": "str2double",
+    "slug": "str2double",
+    "categoryPath": [
+        "strings",
+        "core"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=str2double.js.map

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

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

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

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

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

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