runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/axis.js

@@ -0,0 +1,69 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "axis",
+    "category": "plotting",
+    "keywords": [
+        "axis",
+        "axis limits",
+        "axis equal",
+        "axis tight",
+        "matlab axis"
+    ],
+    "summary": "Control axis limits, aspect behavior, and automatic fitting with MATLAB `axis` semantics.",
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::cmds"
+    },
+    "description": "`axis` is the compact plotting command for changing axes limits and aspect behavior. In RunMat it operates on the active axes state, so it is naturally used after plotting calls or within a selected subplot to reproduce MATLAB `axis` workflows such as `axis([xmin xmax ymin ymax])`, `axis equal`, `axis auto`, and `axis tight`.",
+    "behaviors": [
+        "Passing a four-element numeric vector sets `[xmin xmax ymin ymax]` directly.",
+        "`axis equal` enables equal aspect behavior on the current axes.",
+        "`axis auto` clears explicit limits and returns to automatic fitting.",
+        "`axis tight` uses data-driven fitting behavior while leaving figure-local plot contents unchanged.",
+        "Axis settings are subplot-local because they act on the active axes state."
+    ],
+    "examples": [
+        {
+            "description": "Set explicit x and y limits",
+            "input": "plot(0:0.1:10, sin(0:0.1:10));\naxis([0 10 -1 1]);"
+        },
+        {
+            "description": "Force equal axis scaling",
+            "input": "t = linspace(0, 2*pi, 200);\nplot(cos(t), sin(t));\naxis equal;"
+        },
+        {
+            "description": "Return to automatic fitting inside a subplot",
+            "input": "subplot(1, 2, 1);\nplot(1:5, [1 4 2 5 3]);\naxis tight;\nsubplot(1, 2, 2);\nplot(1:5, [5 4 3 2 1]);\naxis auto;"
+        }
+    ],
+    "links": [
+        {
+            "label": "grid",
+            "url": "./grid"
+        },
+        {
+            "label": "box",
+            "url": "./box"
+        },
+        {
+            "label": "subplot",
+            "url": "./subplot"
+        },
+        {
+            "label": "plot",
+            "url": "./plot"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/cmds.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/cmds.rs"
+    },
+    "key": "axis",
+    "slug": "axis",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=axis.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"axis.js","sourceRoot":"","sources":["../../../src/generated/builtins/axis.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,aAAa;QACb,YAAY;QACZ,YAAY;QACZ,aAAa;KACd;IACD,SAAS,EAAE,2FAA2F;IACtG,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,0BAA0B;KACnC;IACD,aAAa,EAAE,yUAAyU;IACxV,WAAW,EAAE;QACX,8EAA8E;QAC9E,iEAAiE;QACjE,sEAAsE;QACtE,oGAAoG;QACpG,4EAA4E;KAC7E;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,oDAAoD;SAC9D;QACD;YACE,aAAa,EAAE,0BAA0B;YACzC,OAAO,EAAE,iEAAiE;SAC3E;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,iHAAiH;SAC3H;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/bandwidth.js

@@ -0,0 +1,175 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "bandwidth",
+    "category": "math/linalg/structure",
+    "keywords": [
+        "bandwidth",
+        "lower bandwidth",
+        "upper bandwidth",
+        "banded matrix",
+        "structure",
+        "gpu"
+    ],
+    "summary": "Compute the lower and upper bandwidth of a matrix, optionally returning a single side.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Runs a device-side reduction when the acceleration provider implements the `bandwidth` hook; falls back to gathering on providers without support."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::linalg::structure::bandwidth::tests",
+        "integration": "builtins::math::linalg::structure::bandwidth::tests::bandwidth_gpu_roundtrip"
+    },
+    "description": "`bandwidth(A)` inspects the nonzero pattern of a matrix and reports two numbers: the lower bandwidth (how many subdiagonals contain nonzeros) and the upper bandwidth (how many superdiagonals contain nonzeros). These metrics help determine whether a matrix is banded, which is essential for selecting the most efficient solver or factorisation.",
+    "behaviors": [
+        "`bandwidth(A)` returns a row vector `[lower upper]`. A diagonal matrix has `[0 0]`, a strictly upper-triangular matrix has `[0 k]`, and a strictly lower-triangular matrix has `[k 0]`, where `k` counts the furthest nonzero from the main diagonal.",
+        "`bandwidth(A, 'lower')` returns only the lower bandwidth, while `bandwidth(A, 'upper')` returns only the upper bandwidth.",
+        "Nonzero detection treats any value that is not numerically equal to zero (including `NaN` or `Inf`) as nonzero, matching MATLAB semantics.",
+        "Empty matrices and all-zero matrices report `[0 0]`.",
+        "Inputs must be numeric or logical and two-dimensional. Higher-dimensional arrays (with any dimension beyond the second larger than one) raise an error.",
+        "Complex matrices are supported. A complex entry counts as nonzero if either the real or imaginary part is nonzero."
+    ],
+    "examples": [
+        {
+            "description": "Checking the bandwidth of a diagonal matrix",
+            "input": "A = eye(4);\nbw = bandwidth(A)",
+            "output": "bw = [0 0]"
+        },
+        {
+            "description": "Requesting only the lower bandwidth",
+            "input": "A = [-1 0 0; 2 3 0; 4 5 6];\nlower_bw = bandwidth(A, 'lower')",
+            "output": "lower_bw = 2"
+        },
+        {
+            "description": "Requesting only the upper bandwidth",
+            "input": "B = [1 2 0 0; 0 3 4 0; 0 0 5 6];\nupper_bw = bandwidth(B, 'upper')",
+            "output": "upper_bw = 1"
+        },
+        {
+            "description": "Analysing a rectangular matrix",
+            "input": "C = [0 0 7; 8 0 0; 0 9 0; 0 0 10];\nbw = bandwidth(C)",
+            "output": "bw = [1 2]"
+        },
+        {
+            "description": "Working with complex-valued matrices",
+            "input": "Z = [1+2i 0; 0 3-4i; 5i 0];\nbw = bandwidth(Z)",
+            "output": "bw = [2 0]"
+        },
+        {
+            "description": "Inspecting a GPU-resident matrix",
+            "input": "G = gpuArray([0 1 0; 2 0 3; 0 0 0]);\nbw = bandwidth(G)",
+            "output": "bw = [1 1]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What does a bandwidth of `[0 0]` mean?",
+            "answer": "It indicates the matrix is diagonal: all nonzero elements are on the main diagonal."
+        },
+        {
+            "question": "How are rows or columns full of zeros handled?",
+            "answer": "Zero rows or columns do not increase the bandwidth; only nonzero entries affect the result."
+        },
+        {
+            "question": "Does `bandwidth` treat `NaN` values as nonzero?",
+            "answer": "Yes. Any value that is not exactly zero—including `NaN` or `Inf`—counts as nonzero."
+        },
+        {
+            "question": "Can I request only the lower or upper bandwidth?",
+            "answer": "Yes. Pass `'lower'` or `'upper'` as the second argument to obtain a scalar result."
+        },
+        {
+            "question": "Why does `bandwidth` error on higher-dimensional arrays?",
+            "answer": "The builtin matches MATLAB and only operates on two-dimensional matrices. Use `reshape` to collapse trailing singleton dimensions before calling `bandwidth`."
+        },
+        {
+            "question": "Does `bandwidth` work with sparse matrices?",
+            "answer": "RunMat currently stores inputs as dense tensors but mirrors MATLAB's numerical semantics. Future releases will preserve sparsity metadata while returning the same bandwidth values."
+        },
+        {
+            "question": "What precision does the result use?",
+            "answer": "The result is always returned as double precision (`double`), matching MATLAB."
+        },
+        {
+            "question": "Will this function keep my data on the GPU?",
+            "answer": "Yes, when the provider implements the hook: the matrix stays resident on the GPU and only the two bandwidth values are copied back. If the provider lacks support, RunMat gathers the tensor and computes the bandwidth on the CPU instead."
+        },
+        {
+            "question": "Can I call `bandwidth` inside fused expressions?",
+            "answer": "Yes. The builtin returns a small host tensor, so it behaves like any other metadata query."
+        },
+        {
+            "question": "What happens if I pass logical matrices?",
+            "answer": "Logical values are promoted to doubles (0 or 1) internally. `true` entries count as nonzero and contribute to the bandwidth calculation."
+        }
+    ],
+    "links": [
+        {
+            "label": "diag",
+            "url": "./diag"
+        },
+        {
+            "label": "tril",
+            "url": "./tril"
+        },
+        {
+            "label": "triu",
+            "url": "./triu"
+        },
+        {
+            "label": "issymmetric",
+            "url": "./issymmetric"
+        },
+        {
+            "label": "find",
+            "url": "./find"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "ishermitian",
+            "url": "./ishermitian"
+        },
+        {
+            "label": "symrcm",
+            "url": "./symrcm"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/linalg/structure/bandwidth.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/linalg/structure/bandwidth.rs"
+    },
+    "gpu_residency": "You usually do NOT need to move data manually. When the active provider exposes the `bandwidth` hook (the WGPU backend does), RunMat launches a device-side kernel and only reads back the two bandwidth values. Providers without support seamlessly gather the tensor and reuse the CPU implementation, so explicit `gpuArray` / `gather` calls remain optional.",
+    "gpu_behavior": [
+        "`bandwidth` leverages the active acceleration provider when available. The WGPU backend launches a lightweight compute kernel that scans the matrix on-device and returns the lower and upper bandwidths without transferring the entire tensor. Providers that do not implement the `bandwidth` hook trigger a graceful fallback that gathers the matrix and executes the CPU implementation instead. Either way, the result is returned as a small host-side double tensor."
+    ],
+    "key": "bandwidth",
+    "slug": "bandwidth",
+    "categoryPath": [
+        "math",
+        "linalg",
+        "structure"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=bandwidth.js.map

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

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

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

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

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

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

package/dist/generated/builtins/bar.js

@@ -0,0 +1,95 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "bar",
+    "category": "plotting",
+    "keywords": [
+        "bar",
+        "bar chart",
+        "grouped bar chart",
+        "stacked bar chart",
+        "matlab bar",
+        "categorical comparison"
+    ],
+    "summary": "Create bar charts for categorical comparisons, grouped series, stacked values, and MATLAB `bar` workflows.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`bar` uses the modern bar/surface-style rendering path, including GPU-backed paths for supported input combinations."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::bar::tests",
+        "integration": "runmat-plot/tests/renderer_tests.rs"
+    },
+    "description": "`bar` creates vertical bar charts from vectors or matrix-style inputs. In RunMat it returns a bar handle, supports the common MATLAB `bar(y)` workflows as well as grouped and stacked behaviors, and integrates with the shared handle/property system.",
+    "behaviors": [
+        "Vector inputs create a single bar series with implicit category positions.",
+        "Matrix inputs support grouped and stacked bar-style rendering workflows.",
+        "The returned value is a bar handle that can be queried and updated through `get` and `set`.",
+        "Display names, bar width, and face color participate in the shared plotting object/property model.",
+        "RunMat prefers GPU-backed rendering when supported input/layout combinations are present, while preserving the same bar semantics on fallback paths."
+    ],
+    "examples": [
+        {
+            "description": "Create a basic bar chart from a vector",
+            "input": "values = [3 5 2 9];\nbar(values);"
+        },
+        {
+            "description": "Create grouped bars from a matrix",
+            "input": "Y = [3 5 2; 4 6 1; 5 4 3];\nbar(Y);"
+        },
+        {
+            "description": "Style a bar object and label it for the legend",
+            "input": "h = bar([2 4 1 5]);\nset(h, 'FaceColor', 'g', 'DisplayName', 'counts');\nlegend;"
+        }
+    ],
+    "links": [
+        {
+            "label": "hist",
+            "url": "./hist"
+        },
+        {
+            "label": "histogram",
+            "url": "./histogram"
+        },
+        {
+            "label": "pie",
+            "url": "./pie"
+        },
+        {
+            "label": "legend",
+            "url": "./legend"
+        },
+        {
+            "label": "set",
+            "url": "./set"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/bar.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/bar.rs"
+    },
+    "gpu_residency": "`bar` preserves GPU residency where the bar geometry pipeline can consume exported buffers directly. Fallback rendering gathers once and preserves the same grouping/stacking semantics.",
+    "gpu_behavior": [
+        "Bar rendering shares the same plotting architecture as the rest of the plotting stack."
+    ],
+    "key": "bar",
+    "slug": "bar",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=bar.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bar.js","sourceRoot":"","sources":["../../../src/generated/builtins/bar.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,KAAK;IACd,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,KAAK;QACL,WAAW;QACX,mBAAmB;QACnB,mBAAmB;QACnB,YAAY;QACZ,wBAAwB;KACzB;IACD,SAAS,EAAE,4GAA4G;IACvH,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,sHAAsH;KAChI;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,gCAAgC;QACxC,aAAa,EAAE,qCAAqC;KACrD;IACD,aAAa,EAAE,0PAA0P;IACzQ,WAAW,EAAE;QACX,4EAA4E;QAC5E,0EAA0E;QAC1E,6FAA6F;QAC7F,oGAAoG;QACpG,sJAAsJ;KACvJ;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,mCAAmC;SAC7C;QACD;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,qCAAqC;SAC/C;QACD;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,kFAAkF;SAC5F;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,0DAA0D;QACnE,KAAK,EAAE,uGAAuG;KAC/G;IACD,eAAe,EAAE,0LAA0L;IAC3M,cAAc,EAAE;QACd,wFAAwF;KACzF;IACD,KAAK,EAAE,KAAK;IACZ,MAAM,EAAE,KAAK;IACb,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/box.js

@@ -0,0 +1,60 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "box",
+    "category": "plotting",
+    "keywords": [
+        "box",
+        "axes box",
+        "box on",
+        "box off",
+        "matlab box"
+    ],
+    "summary": "Toggle axes box outlines for chart framing, presentation, and MATLAB `box on` / `box off` workflows.",
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::cmds"
+    },
+    "description": "`box` controls whether the current axes draw their outer frame. Like MATLAB, RunMat supports `box on`, `box off`, and bare `box` toggling. This is mainly a presentation/state command, so it is usually used alongside `axis`, `grid`, and subplot-specific styling.",
+    "behaviors": [
+        "`box on` enables the axes frame on the current axes.",
+        "`box off` disables the axes frame on the current axes.",
+        "Calling `box` with no argument toggles the current state.",
+        "Box state is subplot-local and applies to the currently active axes."
+    ],
+    "examples": [
+        {
+            "description": "Turn the axes frame on for a chart",
+            "input": "plot(1:5, [1 4 2 5 3]);\nbox on;"
+        },
+        {
+            "description": "Style subplots independently",
+            "input": "subplot(1, 2, 1);\nplot(1:5, 1:5);\nbox off;\nsubplot(1, 2, 2);\nplot(1:5, [5 4 3 2 1]);\nbox on;"
+        }
+    ],
+    "links": [
+        {
+            "label": "axis",
+            "url": "./axis"
+        },
+        {
+            "label": "grid",
+            "url": "./grid"
+        },
+        {
+            "label": "subplot",
+            "url": "./subplot"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/cmds.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/cmds.rs"
+    },
+    "key": "box",
+    "slug": "box",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=box.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"box.js","sourceRoot":"","sources":["../../../src/generated/builtins/box.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,KAAK;IACd,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,KAAK;QACL,UAAU;QACV,QAAQ;QACR,SAAS;QACT,YAAY;KACb;IACD,SAAS,EAAE,sGAAsG;IACjH,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,0BAA0B;KACnC;IACD,aAAa,EAAE,uQAAuQ;IACtR,WAAW,EAAE;QACX,sDAAsD;QACtD,wDAAwD;QACxD,2DAA2D;QAC3D,sEAAsE;KACvE;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,kCAAkC;SAC5C;QACD;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,mGAAmG;SAC7G;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,KAAK,EAAE,KAAK;IACZ,MAAM,EAAE,KAAK;IACb,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/cat.js

@@ -0,0 +1,186 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "cat",
+    "category": "array/shape",
+    "keywords": [
+        "cat",
+        "concatenate",
+        "array",
+        "dimension",
+        "gpu"
+    ],
+    "summary": "Concatenate arrays along a specified dimension while preserving MATLAB semantics.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Runs on the GPU when the provider offers a native cat hook; otherwise RunMat gathers, concatenates on the host, and uploads the result back to the device."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": null,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::shape::cat::tests",
+        "integration": "builtins::array::shape::cat::tests::cat_gpu_roundtrip"
+    },
+    "description": "`cat(dim, A1, A2, …)` concatenates arrays along the dimension `dim`, producing a new array whose slices along that dimension are the input arrays. The result preserves column-major ordering and shares MATLAB's rules for implicit singleton expansion.",
+    "behaviors": [
+        "`dim` is 1-based and must be a positive integer.",
+        "All inputs must be the same class (double, logical, complex, char, string, or cell).",
+        "Dimensions other than `dim` must match exactly; missing higher dimensions are treated as size `1` automatically.",
+        "The size along `dim` becomes the sum of the corresponding sizes from each input.",
+        "Empty inputs participate naturally—if any dimension is zero, the result is empty.",
+        "`gpuArray` inputs stay on the device when an acceleration provider is registered.",
+        "Append an optional `'like', prototype` pair to request output that matches the prototype's device residency; numeric prototypes may be host tensors or `gpuArray` handles, while logical prototypes must remain on the CPU."
+    ],
+    "examples": [
+        {
+            "description": "Concatenating matrices by stacking rows",
+            "input": "A = [1 2; 3 4];\nB = [5 6; 7 8];\nC = cat(1, A, B)",
+            "output": "C =\n     1     2\n     3     4\n     5     6\n     7     8"
+        },
+        {
+            "description": "Concatenating matrices by appending columns",
+            "input": "left = [1 3; 2 4];\nright = [10 30; 20 40];\nwide = cat(2, left, right)",
+            "output": "wide =\n     1     3    10    30\n     2     4    20    40"
+        },
+        {
+            "description": "Building a 3-D array from 2-D slices",
+            "input": "slice1 = magic(3);\nslice2 = eye(3);\ncube = cat(3, slice1, slice2)"
+        },
+        {
+            "description": "Concatenating logical masks without type changes",
+            "input": "row = logical([1 0 1]);\nmask = cat(1, row, ~row)",
+            "output": "mask =\n   1   0   1\n   0   1   0"
+        },
+        {
+            "description": "Joining character arrays into wider text rows",
+            "input": "lhs = ['Run' ; 'GPU'];\nrhs = ['Mat'; 'Fun'];\nwords = cat(2, lhs, rhs)",
+            "output": "words =\n    RunMat\n    GPUFun"
+        },
+        {
+            "description": "Concatenating string arrays along rows",
+            "input": "names = [\"alpha\" \"beta\"];\nmore = [\"gamma\" \"delta\"];\ncombined = cat(1, names, more)"
+        },
+        {
+            "description": "Appending cell array columns for table-like data",
+            "input": "cols1 = {1, 2; 'a', 'b'};\ncols2 = {3, 4; 'c', 'd'};\ntableCells = cat(2, cols1, cols2)"
+        },
+        {
+            "description": "Keeping gpuArray inputs on the device",
+            "input": "G1 = gpuArray(rand(256, 256));\nG2 = gpuArray(rand(256, 256));\nstacked = cat(3, G1, G2)"
+        },
+        {
+            "description": "Requesting GPU output with the `'like'` prototype",
+            "input": "G = gpuArray(rand(3, 3));\nH = cat(3, zeros(3, 3), ones(3, 3), \"like\", G)"
+        },
+        {
+            "description": "Concatenating complex arrays preserves imaginary parts",
+            "input": "z1 = complex([1 2], [3 4]);\nz2 = complex([5 6], [7 8]);\njoined = cat(2, z1, z2)"
+        },
+        {
+            "description": "Combining empty inputs yields an empty result",
+            "input": "emptyRow = zeros(0, 3);\ncombo = cat(1, emptyRow, emptyRow)"
+        }
+    ],
+    "faqs": [],
+    "links": [
+        {
+            "label": "`reshape`",
+            "url": "./reshape"
+        },
+        {
+            "label": "`permute`",
+            "url": "./permute"
+        },
+        {
+            "label": "`squeeze`",
+            "url": "./squeeze"
+        },
+        {
+            "label": "`gpuArray`",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "`gather`",
+            "url": "./gather"
+        },
+        {
+            "label": "circshift",
+            "url": "./circshift"
+        },
+        {
+            "label": "diag",
+            "url": "./diag"
+        },
+        {
+            "label": "flip",
+            "url": "./flip"
+        },
+        {
+            "label": "fliplr",
+            "url": "./fliplr"
+        },
+        {
+            "label": "flipud",
+            "url": "./flipud"
+        },
+        {
+            "label": "horzcat",
+            "url": "./horzcat"
+        },
+        {
+            "label": "ipermute",
+            "url": "./ipermute"
+        },
+        {
+            "label": "kron",
+            "url": "./kron"
+        },
+        {
+            "label": "repmat",
+            "url": "./repmat"
+        },
+        {
+            "label": "rot90",
+            "url": "./rot90"
+        },
+        {
+            "label": "tril",
+            "url": "./tril"
+        },
+        {
+            "label": "triu",
+            "url": "./triu"
+        },
+        {
+            "label": "vertcat",
+            "url": "./vertcat"
+        }
+    ],
+    "source": {
+        "label": "crates/runmat-runtime/src/builtins/array/shape/cat.rs",
+        "url": "crates/runmat-runtime/src/builtins/array/shape/cat.rs"
+    },
+    "gpu_behavior": [
+        "When every input is a `gpuArray`, RunMat first calls the active provider's `AccelProvider::cat` hook to concatenate the buffers directly on the device. Providers that do not expose this hook trigger a transparent fallback: the operands are gathered to the host, concatenated with the same rules as CPU arrays, and uploaded back to the originating device so downstream work still sees a `gpuArray`. The `'like'` prototype is honoured during fallback, ensuring the final residency matches your request. Mixing host arrays with `gpuArray` inputs is not supported—convert explicitly with `gpuArray` / `gather` to control residency."
+    ],
+    "key": "cat",
+    "slug": "cat",
+    "categoryPath": [
+        "array",
+        "shape"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=cat.js.map

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

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