runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/struct.js

@@ -0,0 +1,149 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "struct",
+    "category": "structs/core",
+    "keywords": [
+        "struct",
+        "structure",
+        "name-value",
+        "record",
+        "struct array"
+    ],
+    "summary": "Create scalar structs or struct arrays from name/value pairs.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Struct construction runs on the host. GPU tensors stay as handles inside the resulting struct or struct array."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::structs::core::r#struct::tests",
+        "integration": "builtins::structs::core::r#struct::tests::struct_preserves_gpu_handles_with_registered_provider"
+    },
+    "description": "`S = struct(...)` creates scalar structs or struct arrays by pairing field names with values. The inputs can be simple name/value pairs, existing structs, or cell arrays whose elements are expanded into struct array entries.",
+    "behaviors": [
+        "Field names must satisfy the MATLAB `isvarname` rules: they start with a letter or underscore and contain only letters, digits, or underscores.",
+        "The last occurrence of a repeated field name wins and overwrites earlier values.",
+        "String scalars, character vectors, and single-element string arrays are accepted as field names.",
+        "`struct()` returns a scalar struct with no fields, while `struct([])` yields a `0×0` struct array.",
+        "When any value input is a cell array, every cell array input must share the same size. Non-cell inputs are replicated across every element of the resulting struct array.",
+        "Passing an existing struct or struct array (`struct(S)`) creates a deep copy; the original data is untouched."
+    ],
+    "examples": [
+        {
+            "description": "Creating a simple structure for named fields",
+            "input": "s = struct(\"name\", \"Ada\", \"score\", 42);\ndisp(s.name);\ndisp(s.score)",
+            "output": "Ada\n42"
+        },
+        {
+            "description": "Building a struct array from paired cell inputs",
+            "input": "names = {\"Ada\", \"Grace\"};\nages = {36, 45};\npeople = struct(\"name\", names, \"age\", ages);\n{people.name}",
+            "output": "    {'Ada'}    {'Grace'}"
+        },
+        {
+            "description": "Broadcasting scalars across a struct array",
+            "input": "ids = struct(\"id\", {101, 102, 103}, \"department\", \"Research\");\n{ids.department}",
+            "output": "    {'Research'}    {'Research'}    {'Research'}"
+        },
+        {
+            "description": "Copying an existing structure",
+            "input": "a = struct(\"id\", 7, \"label\", \"demo\");\nb = struct(a);\nb.id = 8;\ndisp([a.id b.id])",
+            "output": "     7     8"
+        },
+        {
+            "description": "Building an empty struct array",
+            "input": "s = struct([]);\ndisp(size(s))",
+            "output": "     0     0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Do field names have to be valid identifiers?",
+            "answer": "Yes. RunMat mirrors MATLAB and requires names to satisfy `isvarname`. Names must begin with a letter or underscore and may contain letters, digits, and underscores."
+        },
+        {
+            "question": "How do I create a struct array?",
+            "answer": "Provide one or more value arguments as cell arrays with identical sizes. Each cell contributes the value for the corresponding struct element. Non-cell values are replicated across all elements."
+        },
+        {
+            "question": "What happens when the same field name appears more than once?",
+            "answer": "The last value wins; earlier values for the same field are overwritten."
+        },
+        {
+            "question": "Does `struct` gather GPU data back to the CPU?",
+            "answer": "No. GPU tensors remain device-resident handles inside the resulting struct or struct array."
+        },
+        {
+            "question": "Can I pass non-string objects as field names?",
+            "answer": "No. Field names must be provided as string scalars, character vectors, or single-element string arrays. Passing other types raises an error."
+        }
+    ],
+    "links": [
+        {
+            "label": "load",
+            "url": "./load"
+        },
+        {
+            "label": "whos",
+            "url": "./whos"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "fieldnames",
+            "url": "./fieldnames"
+        },
+        {
+            "label": "getfield",
+            "url": "./getfield"
+        },
+        {
+            "label": "isfield",
+            "url": "./isfield"
+        },
+        {
+            "label": "orderfields",
+            "url": "./orderfields"
+        },
+        {
+            "label": "rmfield",
+            "url": "./rmfield"
+        },
+        {
+            "label": "setfield",
+            "url": "./setfield"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/structs/core/struct.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/structs/core/struct.rs"
+    },
+    "gpu_residency": "Usually not. RunMat's planner keeps GPU values resident as long as downstream operations can profit from them. You can still seed GPU residency explicitly with `gpuArray` for MATLAB compatibility; the handles remain untouched inside the struct until another builtin decides to gather or operate on them.",
+    "gpu_behavior": [
+        "`struct` performs all bookkeeping on the host. GPU-resident values—such as tensors created with `gpuArray`—are stored as-is inside the resulting struct or struct array. No kernels are launched and no data is implicitly gathered back to the CPU."
+    ],
+    "key": "struct",
+    "slug": "struct",
+    "categoryPath": [
+        "structs",
+        "core"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=struct.js.map

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

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

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

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

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

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

package/dist/generated/builtins/sub2ind.js

@@ -0,0 +1,157 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "sub2ind",
+    "category": "array/indexing",
+    "keywords": [
+        "sub2ind",
+        "linear index",
+        "column major",
+        "gpu indexing",
+        "nd indexing"
+    ],
+    "summary": "Convert N-D subscripts into MATLAB-style column-major linear indices.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "When a GPU provider exposes the `sub2ind` hook (WGPU today), the conversion runs on the device with bounds and integrality checks; other providers fall back to the host implementation and reupload the result."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::indexing::sub2ind::tests",
+        "integration": "builtins::array::indexing::sub2ind::tests::sub2ind_gpu_roundtrip"
+    },
+    "description": "`sub2ind(sz, s1, s2, ...)` converts row/column (or higher-dimensional) subscripts into MATLAB's column-major linear indexing form. The size vector `sz` defines the extents of the target array, and you must supply one subscript array per dimension.",
+    "behaviors": [
+        "Subscripts can be scalars or arrays. When arrays are provided, they must share the same size. Scalars broadcast to that common shape.",
+        "All subscripts must be positive integers within the corresponding dimension's range.",
+        "The size vector can be a row or column vector. Each element must be a positive integer.",
+        "Complex, NaN, or infinite values are rejected.",
+        "The result uses the same shape as the subscript arrays. Scalars produce a scalar double.",
+        "When any input is a GPU tensor, RunMat computes on the host (to reuse integer semantics) and uploads the resulting indices back to the GPU so fusion and downstream kernels keep operating on device."
+    ],
+    "examples": [
+        {
+            "description": "Converting a single matrix subscript to a linear index",
+            "input": "idx = sub2ind([3 4], 2, 3)",
+            "output": "idx = 8"
+        },
+        {
+            "description": "Mapping multiple subscripts into one-dimensional indices",
+            "input": "rows = [1; 2; 3];\ncols = [3; 3; 3];\nidx = sub2ind([3 5], rows, cols)",
+            "output": "idx =\n     7\n     8\n     9"
+        },
+        {
+            "description": "Handling higher-dimensional array subscripts",
+            "input": "row = [1 1];\ncol = [2 3];\npage = [1 2];\nidx = sub2ind([2 3 4], row, col, page)",
+            "output": "idx = [3 11]"
+        },
+        {
+            "description": "Broadcasting scalar subscripts across array inputs",
+            "input": "rows = [1 2 3];\nidx = sub2ind([3 4], rows, 4)",
+            "output": "idx = [10 11 12]"
+        },
+        {
+            "description": "Retaining GPU residency for batched index conversions",
+            "input": "rows = gpuArray((1:100)');\ncols = gpuArray(ones(100, 1) * 4);\nidx = sub2ind([100 4], rows, cols)",
+            "output": "% idx remains a gpuArray containing the column-major indices.\ndisp(gather(idx(1:5)));\n% Output:\n%    301\n%    302\n%    303\n%    304\n%    305"
+        },
+        {
+            "description": "Detecting invalid out-of-range subscripts",
+            "input": "try\n    idx = sub2ind([3 4], 4, 1);\ncatch ME\n    disp(ME.message);\nend",
+            "output": "Index exceeds the number of rows in dimension 1."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What data types does `sub2ind` accept?",
+            "answer": "Numeric and logical inputs are accepted. Logical values are converted to doubles before validation. Complex, NaN, and infinite values are rejected with a descriptive error."
+        },
+        {
+            "question": "Can the size vector contain zeros?",
+            "answer": "No. Every dimension size must be a positive integer. This matches MATLAB's behavior for index conversion."
+        },
+        {
+            "question": "Do subscripts have to be the same size?",
+            "answer": "Yes. All non-scalar subscripts must share the same size (shape). Scalars broadcast to that common shape."
+        },
+        {
+            "question": "What happens when subscripts are out of range?",
+            "answer": "`sub2ind` throws an error explaining which dimension failed the bounds check. This mirrors MATLAB's run-time error."
+        },
+        {
+            "question": "Does the function support GPU arrays?",
+            "answer": "Yes. With the WGPU provider the conversion happens entirely on device, including validation. Other providers gather the data to the host, compute the indices, and upload them back to the device automatically."
+        },
+        {
+            "question": "Are fractional subscripts rounded?",
+            "answer": "No. Non-integer, NaN, or infinite subscripts raise an error."
+        },
+        {
+            "question": "How is the linear index computed?",
+            "answer": "The output uses MATLAB's column-major convention: `1 + sum((s_k - 1) * stride_k)` where `stride_k` is the product of the preceding dimensions."
+        },
+        {
+            "question": "Can I call `sub2ind` with more subscripts than dimensions?",
+            "answer": "No. You must pass exactly one subscript per dimension listed in the size vector."
+        },
+        {
+            "question": "What about empty outputs?",
+            "answer": "If the subscript arrays are empty, `sub2ind` returns an empty double array with the same shape."
+        },
+        {
+            "question": "Does `sub2ind` change the orientation of row/column vectors?",
+            "answer": "No. The output preserves the orientation (shape) of the subscript arrays, so row vectors stay row vectors and column vectors stay column vectors."
+        }
+    ],
+    "links": [
+        {
+            "label": "ind2sub",
+            "url": "./ind2sub"
+        },
+        {
+            "label": "find",
+            "url": "./find"
+        },
+        {
+            "label": "size",
+            "url": "./size"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/indexing/sub2ind.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/indexing/sub2ind.rs"
+    },
+    "gpu_residency": "```matlab:runnable\nrows = gpuArray((1:100)');\ncols = gpuArray(ones(100, 1) * 4);\nidx = sub2ind([100 4], rows, cols);\n```\n\nExpected behavior:\n\n```matlab\n% idx remains a gpuArray containing the column-major indices.\ndisp(gather(idx(1:5)));\n% Output:\n%    301\n%    302\n%    303\n%    304\n%    305\n```",
+    "gpu_behavior": [
+        "When a WGPU-backed provider is active, `sub2ind` executes entirely on the GPU. The shader mirrors MATLAB's validation rules: it rejects non-finite values, non-integer subscripts, and out-of-range indices, surfacing the same diagnostic messages as the CPU path. Providers that do not yet implement the hook fall back to the host implementation; after the indices are computed they are uploaded back to the active provider so downstream fused kernels continue operating on device data."
+    ],
+    "key": "sub2ind",
+    "slug": "sub2ind",
+    "categoryPath": [
+        "array",
+        "indexing"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=sub2ind.js.map

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

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

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

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

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

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

package/dist/generated/builtins/subplot.js

@@ -0,0 +1,70 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "subplot",
+    "category": "plotting",
+    "keywords": [
+        "subplot",
+        "subplot grid",
+        "multi-panel chart",
+        "matlab subplot",
+        "figure layout"
+    ],
+    "summary": "Split a figure into subplot grids for multi-panel charts, side-by-side comparisons, and MATLAB `subplot` workflows.",
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::subplot::tests"
+    },
+    "description": "`subplot(m, n, p)` selects an axes location inside an `m` by `n` figure grid and returns an axes handle for that slot. In RunMat, subplot selection is the backbone for axes-local plot state: legends, labels, log modes, view angles, and plot children all attach to the currently selected subplot unless an explicit handle is passed.",
+    "behaviors": [
+        "The returned value is an axes handle that can be passed explicitly to later plotting commands.",
+        "Subplot-local metadata stays isolated per axes: titles, legends, limits, log modes, and 3-D view state are all tracked independently.",
+        "Subsequent plotting commands operate on the selected subplot unless another axes handle is passed explicitly.",
+        "Indices are one-based in the MATLAB style. `subplot(2, 2, 3)` selects the third slot in row-major order."
+    ],
+    "examples": [
+        {
+            "description": "Create a 2x2 subplot layout",
+            "input": "subplot(2, 2, 1);\nplot(0:0.1:1, (0:0.1:1).^2);\nsubplot(2, 2, 2);\nscatter(1:5, [5 4 3 2 1]);"
+        },
+        {
+            "description": "Capture and reuse an axes handle explicitly",
+            "input": "ax = subplot(1, 2, 2);\nplot(ax, 0:0.1:1, sin(0:0.1:1));\nget(ax, 'Type')",
+            "output": "ans =\n    'axes'"
+        },
+        {
+            "description": "Show that subplot-local state stays isolated",
+            "input": "subplot(1, 2, 1);\nsemilogx(logspace(0, 2, 50), logspace(0, 2, 50));\nsubplot(1, 2, 2);\nplot(1:5, 1:5);",
+            "output": "% Only the first subplot uses a logarithmic x-axis"
+        }
+    ],
+    "links": [
+        {
+            "label": "plot",
+            "url": "./plot"
+        },
+        {
+            "label": "legend",
+            "url": "./legend"
+        },
+        {
+            "label": "get",
+            "url": "./get"
+        },
+        {
+            "label": "set",
+            "url": "./set"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/subplot.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/subplot.rs"
+    },
+    "key": "subplot",
+    "slug": "subplot",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=subplot.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subplot.js","sourceRoot":"","sources":["../../../src/generated/builtins/subplot.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,SAAS;QACT,cAAc;QACd,mBAAmB;QACnB,gBAAgB;QAChB,eAAe;KAChB;IACD,SAAS,EAAE,qHAAqH;IAChI,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,oCAAoC;KAC7C;IACD,aAAa,EAAE,6UAA6U;IAC5V,WAAW,EAAE;QACX,gGAAgG;QAChG,uIAAuI;QACvI,+GAA+G;QAC/G,0GAA0G;KAC3G;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,gGAAgG;SAC1G;QACD;YACE,aAAa,EAAE,6CAA6C;YAC5D,OAAO,EAAE,2EAA2E;YACpF,QAAQ,EAAE,mBAAmB;SAC9B;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,0GAA0G;YACnH,QAAQ,EAAE,oDAAoD;SAC/D;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;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,8DAA8D;QACvE,KAAK,EAAE,2GAA2G;KACnH;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/sum.js

@@ -0,0 +1,192 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "sum",
+    "category": "math/reduction",
+    "keywords": [
+        "sum",
+        "reduction",
+        "omitnan",
+        "gpu"
+    ],
+    "summary": "Sum elements 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": "Prefers provider reduce_sum_dim / reduce_sum hooks; falls back to host for omitnan, multi-axis, or class-prototype requests."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": true,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::reduction::sum::tests",
+        "integration": "builtins::math::reduction::sum::tests::sum_gpu_provider_roundtrip"
+    },
+    "description": "`sum(X)` adds together elements of scalars, vectors, matrices, and higher-dimensional tensors. When no dimension is supplied, the reduction runs along the first non-singleton dimension.",
+    "behaviors": [
+        "`sum(X)` on an `m × n` matrix returns a row vector (`1 × n`) with column sums.",
+        "`sum(X, 2)` returns a column vector (`m × 1`) containing row sums.",
+        "`sum(X, dims)` accepts a vector of dimensions (e.g., `[1 3]`) and collapses each listed axis while leaving the others untouched.",
+        "`sum(X, 'all')` flattens every dimension into a single scalar sum.",
+        "Logical inputs are promoted to double precision (`true → 1.0`, `false → 0.0`).",
+        "`sum(___, 'omitnan')` ignores `NaN` values; if every element in the slice is `NaN`, the result becomes `0`.",
+        "`sum(___, 'includenan')` (default) propagates `NaN` when any element in the slice is `NaN`.",
+        "`sum(___, outtype)` accepts `'double'`, `'default'`, or `'native'` to control the output class.",
+        "`sum(___, 'like', prototype)` matches the numeric class and residency of `prototype` when supported by the active provider.",
+        "Empty inputs or reductions along dimensions with size `0` return zeros that follow MATLAB shape semantics."
+    ],
+    "examples": [
+        {
+            "description": "Summing the elements of a matrix",
+            "input": "A = [1 2 3; 4 5 6];\ncolSums = sum(A);\nrowSums = sum(A, 2)",
+            "output": "colSums = [5 7 9];\nrowSums = [6; 15]"
+        },
+        {
+            "description": "Summing across multiple dimensions",
+            "input": "B = reshape(1:24, [3 4 2]);\ncollapse = sum(B, [1 3])",
+            "output": "collapse = [48 66 84 102]"
+        },
+        {
+            "description": "Summing with NaN values ignored",
+            "input": "values = [1 NaN 3];\ntotal = sum(values, 'omitnan')",
+            "output": "total = 4"
+        },
+        {
+            "description": "Summing on the GPU and matching an existing prototype",
+            "input": "proto = gpuArray.zeros(1, 1, 'single');\nresult = sum(gpuArray([1 2 3]), 'all', 'like', proto)",
+            "output": "result =\n  1x1 gpuArray  single\n     6"
+        },
+        {
+            "description": "Summing all elements of an array into a scalar",
+            "input": "C = [1 2 3; 4 5 6];\ngrandTotal = sum(C, 'all')",
+            "output": "grandTotal = 21"
+        },
+        {
+            "description": "Summing with native output type",
+            "input": "ints = int32([100 200 300]);\ntotal = sum(ints, 'native')",
+            "output": "total = int32(600)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I use the `sum` function?",
+            "answer": "Use `sum` whenever you need to add together slices of a tensor, whether across a single dimension, multiple dimensions, or the entire dataset."
+        },
+        {
+            "question": "Does `sum` produce double arrays by default?",
+            "answer": "Yes. Unless you request `'native'` or provide a `'like'` prototype, the result is a dense double-precision array on the host."
+        },
+        {
+            "question": "What does `sum(A)` return?",
+            "answer": "For arrays, `sum(A)` reduces along the first non-singleton dimension, returning a new array whose reduced axis has size `1`. Scalars are returned unchanged."
+        },
+        {
+            "question": "How do I compute the sum of a specific dimension?",
+            "answer": "Provide the dimension index: `sum(A, 2)` sums rows, `sum(A, 3)` sums along the third dimension, and so on. You can also pass a vector to collapse multiple dimensions."
+        },
+        {
+            "question": "What happens if all elements are `NaN` and I request `'omitnan'`?",
+            "answer": "`sum(..., 'omitnan')` treats `NaN` values as missing data. If every element in the slice is `NaN`, the result becomes `0`, matching MATLAB semantics."
+        },
+        {
+            "question": "Does `sum` preserve integer classes?",
+            "answer": "Only when you explicitly request `'native'` or `'like'`. Otherwise integers are promoted to double precision so you do not have to manage overflow manually."
+        }
+    ],
+    "links": [
+        {
+            "label": "prod",
+            "url": "./prod"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "cumsum",
+            "url": "./cumsum"
+        },
+        {
+            "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": "diff",
+            "url": "./diff"
+        },
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "median",
+            "url": "./median"
+        },
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "nnz",
+            "url": "./nnz"
+        },
+        {
+            "label": "std",
+            "url": "./std"
+        },
+        {
+            "label": "var",
+            "url": "./var"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/reduction/sum.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/sum.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` yourself. The fusion planner keeps tensors on the GPU whenever the provider exposes the required kernels. To mirror MATLAB, RunMat still accepts and respects explicit `gpuArray` / `gather` usage and the `'like'` option to control residency explicitly.",
+    "gpu_behavior": [
+        "RunMat Accelerate keeps tensors on the GPU whenever a provider is active:\n\n1. If a tensor already resides on the device, the runtime calls the provider’s `reduce_sum_dim` (or `reduce_sum` for whole-array reductions). Successful hooks return a new GPU handle so downstream consumers stay on device. 2. Cases that require extra bookkeeping—such as `'omitnan'`, multi-axis reductions, or `'like'`/`'native'` class coercions—fall back to the host implementation. The runtime gathers the data, computes the correct MATLAB result, and re-uploads it only when a `'like'` prototype demands GPU residency. 3. The fusion planner keeps surrounding elementwise producers and consumers on the GPU, so manual `gpuArray` / `gather` calls are optional unless you want to force residency for interoperability with legacy MATLAB workflows."
+    ],
+    "key": "sum",
+    "slug": "sum",
+    "categoryPath": [
+        "math",
+        "reduction"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=sum.js.map

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

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

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

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

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

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