runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/plot.js

@@ -0,0 +1,123 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "plot",
+    "category": "plotting",
+    "keywords": [
+        "plot",
+        "line plot",
+        "2-D plotting",
+        "plot x y",
+        "matlab plot",
+        "gpu plotting",
+        "runmat plotting"
+    ],
+    "summary": "Create 2-D line plots with handle-based styling, multi-series support, and MATLAB `plot(x, y)` semantics.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "Plot is a rendering sink. GPU inputs can remain resident when the shared plotting device is available; otherwise RunMat gathers once before rendering."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::plot::tests",
+        "integration": "runmat-plot/tests/renderer_tests.rs"
+    },
+    "description": "`plot` is the core RunMat builtin for 2-D line charts. It supports MATLAB-style `plot(y)`, `plot(x, y)`, and multi-series call forms, returns a line handle, and participates in the shared plotting object/property system used by `get` and `set`. In RunMat, `plot` is also GPU-aware: when plotting-compatible GPU buffers are available, line geometry can stay on device through the rendering path rather than being copied back to the host first.",
+    "behaviors": [
+        "`plot(y)` uses `1:n` as the implicit x-axis, matching MATLAB shorthand behavior.",
+        "`plot(x, y)` requires the same element count in both inputs. Row and column vectors are both accepted.",
+        "Multiple data pairs in one call create multiple line objects and return the handle for the first created series, matching common MATLAB plotting conventions.",
+        "The returned handle works with `get` and `set`, so line color, width, display names, and marker properties can be inspected or updated after plotting.",
+        "Plotting is subplot-local. If the active axes come from `subplot`, the line is attached to that subplot rather than globally mutating every axes in the figure.",
+        "RunMat treats `plot` as a rendering sink: fusion stops at the builtin, but GPU residency is preserved on the happy path when the shared plotting device is installed."
+    ],
+    "options": [
+        "Style strings like `'-'`, `'--'`, `':'`, `'o'`, `'x'`, and combined forms such as `'r--o'` are accepted in MATLAB-style plot calls.",
+        "Name/value property updates are typically applied after plotting through `set(h, ...)`, where `h` is the returned line handle.",
+        "Display names set during or after plotting are used by `legend` when labels are not passed explicitly."
+    ],
+    "examples": [
+        {
+            "description": "Plot paired x/y data as a basic line chart",
+            "input": "x = linspace(0, 2*pi, 200);\ny = sin(x);\nh = plot(x, y);",
+            "output": "% h is a numeric handle for the first line object"
+        },
+        {
+            "description": "Use MATLAB-style y-only shorthand",
+            "input": "samples = [1 4 2 5 3];\nplot(samples);",
+            "output": "% RunMat uses 1:length(samples) for the x-axis"
+        },
+        {
+            "description": "Create multiple series and drive the legend from display names",
+            "input": "x = linspace(0, 2*pi, 200);\nh1 = plot(x, sin(x));\nset(h1, 'DisplayName', 'sin(x)', 'LineWidth', 2);\nhold on;\nh2 = plot(x, cos(x));\nset(h2, 'DisplayName', 'cos(x)');\nlegend;",
+            "output": "% The legend uses the line DisplayName properties"
+        },
+        {
+            "description": "Inspect and update a plotted line through handles",
+            "input": "x = 0:0.1:1;\nh = plot(x, x.^2);\nget(h, 'Type')\nset(h, 'Color', 'r', 'Marker', 'o', 'MarkerSize', 6);",
+            "output": "ans =\n    'line'"
+        }
+    ],
+    "links": [
+        {
+            "label": "semilogx",
+            "url": "./semilogx"
+        },
+        {
+            "label": "semilogy",
+            "url": "./semilogy"
+        },
+        {
+            "label": "loglog",
+            "url": "./loglog"
+        },
+        {
+            "label": "scatter",
+            "url": "./scatter"
+        },
+        {
+            "label": "stairs",
+            "url": "./stairs"
+        },
+        {
+            "label": "legend",
+            "url": "./legend"
+        },
+        {
+            "label": "get",
+            "url": "./get"
+        },
+        {
+            "label": "set",
+            "url": "./set"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/plot.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/plot.rs"
+    },
+    "gpu_residency": "`plot` preserves GPU residency when the plotting context can consume exported GPU buffers directly. If the active plotting path cannot use the input buffers, RunMat gathers once before rendering while keeping the resulting figure semantics unchanged.",
+    "gpu_behavior": [
+        "On the GPU happy path, RunMat reuses exported plot input buffers and emits renderer-ready line geometry without a full host round-trip.",
+        "Marker-heavy or otherwise unsupported combinations can fall back to host materialization while preserving the same visible result and handle semantics."
+    ],
+    "key": "plot",
+    "slug": "plot",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=plot.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plot.js","sourceRoot":"","sources":["../../../src/generated/builtins/plot.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,cAAc;QACd,UAAU;QACV,aAAa;QACb,cAAc;QACd,iBAAiB;KAClB;IACD,SAAS,EAAE,2GAA2G;IACtH,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,wJAAwJ;KAClK;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,4bAA4b;IAC3c,WAAW,EAAE;QACX,kFAAkF;QAClF,wGAAwG;QACxG,+JAA+J;QAC/J,wJAAwJ;QACxJ,iKAAiK;QACjK,uKAAuK;KACxK;IACD,SAAS,EAAE;QACT,qIAAqI;QACrI,gIAAgI;QAChI,wGAAwG;KACzG;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,2DAA2D;YACpE,QAAQ,EAAE,mDAAmD;SAC9D;QACD;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,wCAAwC;YACjD,QAAQ,EAAE,gDAAgD;SAC3D;QACD;YACE,aAAa,EAAE,gEAAgE;YAC/E,OAAO,EAAE,oLAAoL;YAC7L,QAAQ,EAAE,mDAAmD;SAC9D;QACD;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,yGAAyG;YAClH,QAAQ,EAAE,mBAAmB;SAC9B;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;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,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,4PAA4P;IAC7Q,cAAc,EAAE;QACd,yIAAyI;QACzI,yJAAyJ;KAC1J;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/plot3.js

@@ -0,0 +1,92 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "plot3",
+    "category": "plotting",
+    "keywords": [
+        "plot3",
+        "3-D line plot",
+        "trajectory plot",
+        "parametric curve",
+        "matlab plot3",
+        "spatial path"
+    ],
+    "summary": "Create 3-D line plots for trajectories, parametric curves, and spatial paths with MATLAB `plot3` semantics.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`plot3` uses the dedicated 3-D line rendering path and can keep plotting-compatible GPU inputs resident on device."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::plot3::tests"
+    },
+    "description": "`plot3` creates line plots in 3-D space from matching x, y, and z inputs. In RunMat it returns a line3 handle, participates in the graphics-object system, and supports both host and GPU-backed inputs through the dedicated 3-D line pipeline.",
+    "behaviors": [
+        "`plot3(x, y, z)` requires matching element counts in all three inputs.",
+        "The builtin returns a 3-D line handle that can be inspected and updated through `get` and `set`.",
+        "Multiple 3-D series in one call create multiple line objects and return the handle for the first created series.",
+        "`plot3` is camera-aware and naturally pairs with `view` and `zlabel` in the subplot-local 3-D state model.",
+        "GPU-backed 3-D line rendering is used when the shared plotting device can consume exported buffers directly."
+    ],
+    "examples": [
+        {
+            "description": "Create a 3-D helix",
+            "input": "t = linspace(0, 6*pi, 300);\nplot3(cos(t), sin(t), t);"
+        },
+        {
+            "description": "Plot multiple 3-D trajectories and label them",
+            "input": "t = linspace(0, 4*pi, 200);\nh1 = plot3(cos(t), sin(t), t);\nset(h1, 'DisplayName', 'helix A');\nhold on;\nh2 = plot3(cos(t), sin(t), -t);\nset(h2, 'DisplayName', 'helix B');\nlegend;"
+        },
+        {
+            "description": "Control the camera and z-axis after plotting",
+            "input": "t = linspace(0, 4*pi, 150);\nh = plot3(cos(t), sin(t), t);\nzlabel('Height');\nview(45, 20);\nget(h, 'Type')",
+            "output": "ans =\n    'line'"
+        }
+    ],
+    "links": [
+        {
+            "label": "scatter3",
+            "url": "./scatter3"
+        },
+        {
+            "label": "view",
+            "url": "./view"
+        },
+        {
+            "label": "zlabel",
+            "url": "./zlabel"
+        },
+        {
+            "label": "legend",
+            "url": "./legend"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/plot3.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/plot3.rs"
+    },
+    "gpu_residency": "`plot3` preserves GPU residency when the 3-D line pipeline can consume exported coordinate buffers directly. Fallback rendering gathers once while preserving the same handle and axes semantics.",
+    "gpu_behavior": [
+        "The dedicated 3-D line pipeline is separate from 2-D `plot`, which keeps camera-aware rendering and bounds handling explicit.",
+        "Subview state, labels, and line object behavior remain identical across GPU and host fallback paths."
+    ],
+    "key": "plot3",
+    "slug": "plot3",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=plot3.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plot3.js","sourceRoot":"","sources":["../../../src/generated/builtins/plot3.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,OAAO;QACP,eAAe;QACf,iBAAiB;QACjB,kBAAkB;QAClB,cAAc;QACd,cAAc;KACf;IACD,SAAS,EAAE,6GAA6G;IACxH,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,oHAAoH;KAC9H;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,kCAAkC;KAC3C;IACD,aAAa,EAAE,kPAAkP;IACjQ,WAAW,EAAE;QACX,wEAAwE;QACxE,kGAAkG;QAClG,kHAAkH;QAClH,4GAA4G;QAC5G,8GAA8G;KAC/G;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,oBAAoB;YACnC,OAAO,EAAE,wDAAwD;SAClE;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,yLAAyL;SACnM;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,8GAA8G;YACvH,QAAQ,EAAE,mBAAmB;SAC9B;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,4DAA4D;QACrE,KAAK,EAAE,yGAAyG;KACjH;IACD,eAAe,EAAE,mMAAmM;IACpN,cAAc,EAAE;QACd,+HAA+H;QAC/H,sGAAsG;KACvG;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/plus.js

@@ -0,0 +1,248 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "plus",
+    "category": "math/elementwise",
+    "keywords": [
+        "plus",
+        "element-wise addition",
+        "+",
+        "gpu",
+        "implicit expansion"
+    ],
+    "summary": "Element-wise addition A + B with MATLAB-compatible implicit expansion, complex support, and GPU fallbacks.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/plus.html"
+    ],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Uses provider elem_add when both operands share a shape, scalar_add when exactly one operand is a scalar, and gathers to host for implicit expansion or unsupported operand types."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::elementwise::plus::tests::plus_scalar_numbers",
+        "integration": "builtins::math::elementwise::plus::tests::plus_row_column_broadcast",
+        "gpu": "builtins::math::elementwise::plus::tests::plus_gpu_pair_roundtrip",
+        "wgpu": "builtins::math::elementwise::plus::tests::plus_wgpu_matches_cpu_elementwise",
+        "like_gpu": "builtins::math::elementwise::plus::tests::plus_like_gpu_prototype_keeps_residency",
+        "like_host": "builtins::math::elementwise::plus::tests::plus_like_host_gathers_gpu_value",
+        "like_complex": "builtins::math::elementwise::plus::tests::plus_like_complex_prototype_yields_complex"
+    },
+    "description": "`plus(A, B)` (or the operator form `A + B`) adds corresponding elements of `A` and `B`, honouring MATLAB's implicit expansion rules so that scalars and singleton dimensions broadcast automatically.",
+    "behaviors": [
+        "Supports real, complex, logical, and character inputs; logical and character data are promoted to double precision before addition.",
+        "Implicit expansion works across any dimension, provided the non-singleton extents match. Size mismatches raise the standard MATLAB-compatible error message.",
+        "Complex operands follow MATLAB's analytic rule `(a + ib) + (c + id) = (a + c) + i(b + d)`.",
+        "Empty dimensions propagate naturally—if either operand has a zero-sized dimension after broadcasting, the result is empty with the broadcasted shape.",
+        "Integer inputs promote to double precision before addition, mirroring MATLAB behaviour and keeping numeric tower rules consistent with other RunMat arithmetic builtins.",
+        "The optional `'like'` prototype makes the output adopt the residency (host or GPU) and complexity characteristics of the prototype, which is particularly useful for keeping implicit-expansion expressions on the device."
+    ],
+    "examples": [
+        {
+            "description": "Adding two matrices element-wise",
+            "input": "A = [1 2 3; 4 5 6];\nB = [7 8 9; 1 2 3];\nS = plus(A, B)",
+            "output": "S =\n     8    10    12\n     5     7     9"
+        },
+        {
+            "description": "Adding a scalar to every element of a matrix",
+            "input": "A = magic(3);\nshifted = plus(A, 0.5)",
+            "output": "shifted =\n    8.5    1.5    6.5\n    3.5    5.5    9.5\n   10.5    7.5    2.5"
+        },
+        {
+            "description": "Using implicit expansion between a column and row vector",
+            "input": "col = (1:3)';\nrow = [10 20 30];\nm = plus(col, row)",
+            "output": "m =\n    11    21    31\n    12    22    32\n    13    23    33"
+        },
+        {
+            "description": "Adding complex inputs element-wise",
+            "input": "z1 = [1+2i, 3-4i];\nz2 = [2-1i, -1+1i];\nsumz = plus(z1, z2)",
+            "output": "sumz =\n     3 + 1i     2 - 3i"
+        },
+        {
+            "description": "Adding character codes to produce numeric arrays",
+            "input": "letters = 'ABC';\ncodes = plus(letters, 2)",
+            "output": "codes = [67 68 69]"
+        },
+        {
+            "description": "Keeping element-wise sums on the GPU with `'like'`",
+            "input": "proto = gpuArray.zeros(1, 1);\nG1 = gpuArray([1 2 3]);\nG2 = gpuArray([4 5 6]);\ndeviceSum = plus(G1, G2, 'like', proto);\nresult = gather(deviceSum)",
+            "output": "deviceSum =\n  1x3 gpuArray\n     5     7     9\nresult =\n     5     7     9"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `plus` support MATLAB implicit expansion?",
+            "answer": "Yes. Any singleton dimensions expand automatically. If a dimension has incompatible non-singleton extents, `plus` raises the standard size-mismatch error."
+        },
+        {
+            "question": "What numeric type does `plus` return?",
+            "answer": "Results are double precision for real inputs and complex double when either operand is complex. Logical and character inputs are promoted to double before addition."
+        },
+        {
+            "question": "Can I add gpuArrays and host scalars?",
+            "answer": "Yes. RunMat keeps the computation on the GPU when the scalar is numeric. For other host operand types, the runtime gathers the gpuArray and computes on the CPU."
+        },
+        {
+            "question": "Does `plus` preserve gpuArray residency after a fallback?",
+            "answer": "When a fallback occurs (for example, implicit expansion that the provider does not implement), the resulting array stays on the host by default. Provide a `'like', gpuArray(...)` prototype if you need the runtime to re-upload the final result automatically."
+        },
+        {
+            "question": "How can I force the result to stay on the GPU?",
+            "answer": "Provide a `'like'` prototype: `plus(A, B, 'like', gpuArray.zeros(1, 1))` keeps the result on the device even if one of the inputs originated on the host."
+        },
+        {
+            "question": "How are empty arrays handled?",
+            "answer": "Empty dimensions propagate. If either operand has an extent of zero in the broadcasted shape, the result is empty with that broadcasted shape."
+        },
+        {
+            "question": "Are integer inputs supported?",
+            "answer": "Yes. Integers promote to double precision during the addition, matching other RunMat arithmetic builtins."
+        },
+        {
+            "question": "Can I mix complex and real operands?",
+            "answer": "Absolutely. The result is complex, with broadcasting rules identical to MATLAB."
+        },
+        {
+            "question": "What about string arrays?",
+            "answer": "String arrays are not numeric and therefore raise an error when passed to `plus`."
+        }
+    ],
+    "links": [
+        {
+            "label": "mtimes",
+            "url": "./mtimes"
+        },
+        {
+            "label": "times",
+            "url": "./times"
+        },
+        {
+            "label": "ldivide",
+            "url": "./ldivide"
+        },
+        {
+            "label": "rdivide",
+            "url": "./rdivide"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "abs",
+            "url": "./abs"
+        },
+        {
+            "label": "angle",
+            "url": "./angle"
+        },
+        {
+            "label": "conj",
+            "url": "./conj"
+        },
+        {
+            "label": "double",
+            "url": "./double"
+        },
+        {
+            "label": "exp",
+            "url": "./exp"
+        },
+        {
+            "label": "expm1",
+            "url": "./expm1"
+        },
+        {
+            "label": "factorial",
+            "url": "./factorial"
+        },
+        {
+            "label": "gamma",
+            "url": "./gamma"
+        },
+        {
+            "label": "hypot",
+            "url": "./hypot"
+        },
+        {
+            "label": "imag",
+            "url": "./imag"
+        },
+        {
+            "label": "log",
+            "url": "./log"
+        },
+        {
+            "label": "log10",
+            "url": "./log10"
+        },
+        {
+            "label": "log1p",
+            "url": "./log1p"
+        },
+        {
+            "label": "log2",
+            "url": "./log2"
+        },
+        {
+            "label": "minus",
+            "url": "./minus"
+        },
+        {
+            "label": "pow2",
+            "url": "./pow2"
+        },
+        {
+            "label": "power",
+            "url": "./power"
+        },
+        {
+            "label": "real",
+            "url": "./real"
+        },
+        {
+            "label": "sign",
+            "url": "./sign"
+        },
+        {
+            "label": "single",
+            "url": "./single"
+        },
+        {
+            "label": "sqrt",
+            "url": "./sqrt"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/elementwise/plus.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/plus.rs"
+    },
+    "gpu_residency": "RunMat's auto-offload planner keeps tensors on the GPU whenever fused expressions benefit from device execution. Explicit `gpuArray` / `gather` calls remain supported for MATLAB code that manages residency manually. When the active provider lacks the kernels needed for a particular call (for example, implicit expansion between gpuArrays of different shapes), RunMat gathers back to the host, computes the MATLAB-accurate result, and resumes execution seamlessly.",
+    "gpu_behavior": [
+        "When a gpuArray provider is active:\n\n1. If both operands are gpuArrays with identical shapes, RunMat dispatches to the provider's `elem_add` hook. 2. If one operand is a scalar (host or device) and the other is a gpuArray, the runtime calls `scalar_add` to keep the result on the device. 3. The fusion planner treats `plus` as a fusible elementwise node, so adjacent elementwise producers/consumers can execute inside a single WGSL kernel or provider-optimised pipeline, avoiding spurious host↔device transfers. 4. Implicit-expansion workloads (e.g., mixing row and column vectors) or unsupported operand kinds gather transparently to host memory, compute the result with full MATLAB semantics, and return a host tensor unless a `'like'` GPU prototype is supplied—in which case the runtime re-uploads the output to honour the residency request."
+    ],
+    "key": "plus",
+    "slug": "plus",
+    "categoryPath": [
+        "math",
+        "elementwise"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=plus.js.map

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

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

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

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

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

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