runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/surf.js

@@ -0,0 +1,105 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "surf",
+    "category": "plotting",
+    "keywords": [
+        "surf",
+        "surface plot",
+        "3-D surface",
+        "height map",
+        "matlab surf",
+        "gpu surface rendering"
+    ],
+    "summary": "Create shaded 3-D surface plots from grids or mesh coordinates with GPU-backed rendering and MATLAB `surf` semantics.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`surf` uses the shared surface pipeline. GPU-friendly inputs can stay resident through the rendering path when the plotting device is available."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::surf::tests",
+        "integration": "runmat-plot/tests/renderer_tests.rs"
+    },
+    "description": "`surf` creates shaded 3-D surface plots from either vector axes plus a height grid or meshgrid-style coordinate matrices. In RunMat it returns a surface handle, participates in the same graphics-object system as other plotting builtins, and uses the shared surface rendering path that also underpins image and composite surface workflows.",
+    "behaviors": [
+        "`surf(Z)` uses implicit axes, while `surf(X, Y, Z)` accepts either vector axes or meshgrid-style coordinate matrices, following MATLAB `surf` call forms.",
+        "The returned value is a surface handle that can be inspected and updated through `get` and `set`.",
+        "Surface plots naturally interact with `view`, `zlabel`, `colorbar`, `colormap`, and `shading` because they all operate on the same subplot-local axes state.",
+        "GPU-backed surface rendering is the preferred path when exported buffers and the shared plotting device are available; otherwise RunMat gathers once and renders the same surface semantics on the host path.",
+        "`surf` is the shaded/fill-oriented member of the surface family, while `mesh` emphasizes wireframe rendering and `surfc` adds contour overlays."
+    ],
+    "examples": [
+        {
+            "description": "Create a shaded surface from a height grid",
+            "input": "[X, Y] = meshgrid(linspace(-2, 2, 80), linspace(-2, 2, 80));\nZ = sin(X.^2 + Y.^2) ./ (1 + X.^2 + Y.^2);\nsurf(X, Y, Z);"
+        },
+        {
+            "description": "Pair surf with colormap, shading, and colorbar",
+            "input": "[X, Y] = meshgrid(linspace(-3, 3, 100), linspace(-3, 3, 100));\nZ = cos(X) .* sin(Y);\nsurf(X, Y, Z);\ncolormap('jet');\nshading interp;\ncolorbar;"
+        },
+        {
+            "description": "Adjust camera state and z-axis labeling for a surface",
+            "input": "[X, Y] = meshgrid(linspace(-2, 2, 60), linspace(-2, 2, 60));\nZ = X .* exp(-X.^2 - Y.^2);\nh = surf(X, Y, Z);\nzlabel('Height');\nview(45, 30);\nget(h, 'Type')",
+            "output": "ans =\n    'surface'"
+        }
+    ],
+    "links": [
+        {
+            "label": "mesh",
+            "url": "./mesh"
+        },
+        {
+            "label": "surfc",
+            "url": "./surfc"
+        },
+        {
+            "label": "view",
+            "url": "./view"
+        },
+        {
+            "label": "zlabel",
+            "url": "./zlabel"
+        },
+        {
+            "label": "colormap",
+            "url": "./colormap"
+        },
+        {
+            "label": "shading",
+            "url": "./shading"
+        },
+        {
+            "label": "colorbar",
+            "url": "./colorbar"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/surf.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/surf.rs"
+    },
+    "gpu_residency": "`surf` preserves GPU residency on the happy path through the shared surface rendering pipeline. When a direct GPU render path is not available for the active input combination, RunMat gathers once and builds the same surface plot semantics on the fallback path.",
+    "gpu_behavior": [
+        "The surface pipeline is shared across multiple plot families, which keeps `surf` aligned with image, contour-composite, and surface-style rendering behavior.",
+        "Surface color limits and subplot-local metadata stay consistent regardless of whether the geometry is emitted from GPU buffers or host tensors."
+    ],
+    "key": "surf",
+    "slug": "surf",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=surf.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"surf.js","sourceRoot":"","sources":["../../../src/generated/builtins/surf.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,cAAc;QACd,aAAa;QACb,YAAY;QACZ,aAAa;QACb,uBAAuB;KACxB;IACD,SAAS,EAAE,uHAAuH;IAClI,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,kJAAkJ;KAC5J;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,oVAAoV;IACnW,WAAW,EAAE;QACX,2JAA2J;QAC3J,mGAAmG;QACnG,8JAA8J;QAC9J,+MAA+M;QAC/M,iJAAiJ;KAClJ;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,0HAA0H;SACpI;QACD;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,qJAAqJ;SAC/J;QACD;YACE,aAAa,EAAE,uDAAuD;YACtE,OAAO,EAAE,iKAAiK;YAC1K,QAAQ,EAAE,sBAAsB;SACjC;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,eAAe,EAAE,uQAAuQ;IACxR,cAAc,EAAE;QACd,+JAA+J;QAC/J,iJAAiJ;KAClJ;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/surfc.js

@@ -0,0 +1,90 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "surfc",
+    "category": "plotting",
+    "keywords": [
+        "surfc",
+        "surface with contour",
+        "composite surface plot",
+        "projected contour overlay",
+        "matlab surfc"
+    ],
+    "summary": "Create composite surface-and-contour plots for scalar fields with MATLAB `surfc` semantics and projected contour overlays.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`surfc` combines the shared surface path with the modern contour path instead of relying on a separate legacy composite implementation."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::surfc::tests"
+    },
+    "description": "`surfc` is the composite member of the surface family: it combines a shaded `surf`-style surface with contour lines projected onto the base plane. In RunMat the returned handle is the primary surface handle, while the contour overlay is added as the secondary composite child. That keeps the composite behavior explicit without reintroducing a separate legacy plotting stack.",
+    "behaviors": [
+        "`surfc` shares the same surface semantics as `surf` for the primary surface object.",
+        "The returned handle is the surface handle for the composite result, while contour overlays are attached as the secondary composite plot content.",
+        "The contour overlay uses the same modern contour-generation path as `contour`, rather than a one-off composite implementation.",
+        "Colormap, colorbar, view, and subplot-local state all operate on the composite through the same shared axes metadata model.",
+        "GPU-aware execution applies to both the surface side and the contour side where supported."
+    ],
+    "examples": [
+        {
+            "description": "Create a shaded surface with projected contour lines",
+            "input": "[X, Y] = meshgrid(linspace(-2, 2, 60), linspace(-2, 2, 60));\nZ = X .* exp(-X.^2 - Y.^2);\nsurfc(X, Y, Z);"
+        },
+        {
+            "description": "Style the composite with colormap and camera controls",
+            "input": "[X, Y] = meshgrid(linspace(-3, 3, 80), linspace(-3, 3, 80));\nZ = cos(X) .* sin(Y);\nh = surfc(X, Y, Z);\ncolormap('turbo');\ncolorbar;\nview(45, 25);"
+        },
+        {
+            "description": "Inspect the returned primary surface handle",
+            "input": "[X, Y] = meshgrid(1:20, 1:20);\nZ = X + Y;\nh = surfc(X, Y, Z);\nget(h, 'Type')",
+            "output": "ans =\n    'surface'"
+        }
+    ],
+    "links": [
+        {
+            "label": "surf",
+            "url": "./surf"
+        },
+        {
+            "label": "meshc",
+            "url": "./meshc"
+        },
+        {
+            "label": "contour",
+            "url": "./contour"
+        },
+        {
+            "label": "contourf",
+            "url": "./contourf"
+        },
+        {
+            "label": "view",
+            "url": "./view"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/surfc.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/surfc.rs"
+    },
+    "key": "surfc",
+    "slug": "surfc",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=surfc.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"surfc.js","sourceRoot":"","sources":["../../../src/generated/builtins/surfc.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,sBAAsB;QACtB,wBAAwB;QACxB,2BAA2B;QAC3B,cAAc;KACf;IACD,SAAS,EAAE,4HAA4H;IACvI,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,yIAAyI;KACnJ;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,yXAAyX;IACxY,WAAW,EAAE;QACX,qFAAqF;QACrF,kJAAkJ;QAClJ,gIAAgI;QAChI,6HAA6H;QAC7H,4FAA4F;KAC7F;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,sDAAsD;YACrE,OAAO,EAAE,4GAA4G;SACtH;QACD;YACE,aAAa,EAAE,uDAAuD;YACtE,OAAO,EAAE,wJAAwJ;SAClK;QACD;YACE,aAAa,EAAE,6CAA6C;YAC5D,OAAO,EAAE,iFAAiF;YAC1F,QAAQ,EAAE,sBAAsB;SACjC;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,4DAA4D;QACrE,KAAK,EAAE,yGAAyG;KACjH;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/svd.js

@@ -0,0 +1,150 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "svd",
+    "category": "math/linalg/factor",
+    "keywords": [
+        "svd",
+        "singular value decomposition",
+        "linalg",
+        "economy",
+        "vector",
+        "gpu"
+    ],
+    "summary": "Singular value decomposition with full, economy, and vectorised forms.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "No provider hook today; gpuArray inputs gather to host, execute the CPU SVD, and return host tensors."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::linalg::factor::svd::tests",
+        "integration": "builtins::math::linalg::factor::svd::tests::svd_three_outputs_reconstruct"
+    },
+    "description": "`svd(A)` computes the singular value decomposition of a real or complex matrix `A`. It factors `A` into the product `U * S * V'`, where `U` and `V` are orthogonal/unitary matrices and `S` is diagonal (or rectangular diagonal) with non-negative, descending singular values.",
+    "behaviors": [
+        "Single output `s = svd(A)` returns the singular values as a column vector sorted in descending order.",
+        "Three outputs `[U,S,V] = svd(A)` return the full-sized factors with `U` square `m×m`, `S` shaped `m×n`, and `V` square `n×n` (`m = size(A,1)`, `n = size(A,2)`).",
+        "Economy form `[U,S,V] = svd(A,'econ')` (or `svd(A,0)`) reduces the shapes to the rank-defining dimension so that `U` and `V` drop the redundant orthogonal columns.",
+        "Vector form `[U,s,V] = svd(A,'vector')` supplies the singular values as a vector instead of a diagonal matrix. You can combine `'vector'` with `'econ'`.",
+        "Logical and integer inputs are promoted to double precision before factorisation.",
+        "Complex inputs yield unitary `U` and `V` (conjugate-transpose preserves orthogonality) with real, non-negative singular values.",
+        "Empty matrices, row/column vectors, and scalars are all supported and follow MATLAB’s shape conventions."
+    ],
+    "examples": [
+        {
+            "description": "Getting the singular values of a matrix",
+            "input": "A = [1 2 3; 4 5 6; 7 8 9];\ns = svd(A)"
+        },
+        {
+            "description": "Full SVD and reconstruction of a square matrix",
+            "input": "A = [3 1; 0 2];\n[U,S,V] = svd(A);\nA_recon = U * S * V'"
+        },
+        {
+            "description": "Economy-size SVD for a tall matrix",
+            "input": "A = randn(6, 3);\n[U,S,V] = svd(A, 'econ');\nsize(U) %  6 x 3\nsize(S) %  3 x 3\nsize(V) %  3 x 3"
+        },
+        {
+            "description": "Economy-size SVD for a wide matrix",
+            "input": "A = randn(3, 6);\n[U,S,V] = svd(A, 'econ');\nsize(U) %  3 x 3\nsize(S) %  3 x 6\nsize(V) %  6 x 6"
+        },
+        {
+            "description": "Requesting vector form of the singular values",
+            "input": "A = [10 0; 0 1];\n[U,s,V] = svd(A, 'vector')"
+        },
+        {
+            "description": "Computing the SVD of a complex matrix",
+            "input": "A = [1+2i, 2-1i; 0, 3i];\n[U,S,V] = svd(A)"
+        },
+        {
+            "description": "Running `svd` on a `gpuArray` (automatic host fallback today)",
+            "input": "G = gpuArray(randn(128, 64));\ns = svd(G);           % Values are gathered to host transparently"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How are the singular values ordered?",
+            "answer": "They are returned in non-increasing order. MATLAB’s sign conventions are followed: values are non-negative and appear on the diagonal of `S` (or inside the vector form)."
+        },
+        {
+            "question": "What is the difference between full and economy forms?",
+            "answer": "Full SVD returns square `U` and `V` (`m×m` and `n×n`). Economy SVD trims them to `m×min(m,n)` and `n×min(m,n)`. The `S` factor keeps the same column dimension as the input; it is `min(m,n)×min(m,n)` when `m ≥ n` and `min(m,n)×n` when `m < n`. Use economy when you do not need the redundant orthogonal columns."
+        },
+        {
+            "question": "What does the `\"vector\"` option change?",
+            "answer": "It affects the second output. With `\"vector\"`, `S` is returned as a column vector of singular values, matching `svd(A)` in the single-output form. Without it, `S` is a diagonal matrix."
+        },
+        {
+            "question": "Can I mix `'econ'` and `'vector'`?",
+            "answer": "Yes. Any order of the options is accepted (`svd(A,'vector','econ')` and `svd(A,'econ','vector')` both work), and the returned dimensions mirror MATLAB’s behaviour."
+        },
+        {
+            "question": "What happens with scalars or empty matrices?",
+            "answer": "`svd` of a scalar returns its absolute value. Empty matrices return empty factors with consistent dimensions so that downstream code can continue to operate without special cases."
+        },
+        {
+            "question": "Does RunMat require BLAS/LAPACK for `svd`?",
+            "answer": "No. The builtin is always available. When BLAS/LAPACK is enabled, the host implementation leverages those libraries through `nalgebra` for performance; otherwise a pure-Rust algorithm is used under the hood."
+        },
+        {
+            "question": "Will the results stay on the GPU?",
+            "answer": "Not yet. Presently the builtin gathers GPU operands to the host, runs the CPU factorisation, and returns host tensors. The GPU spec already reserves a hook so providers can keep everything device-resident once GPU kernels land."
+        }
+    ],
+    "links": [
+        {
+            "label": "eig",
+            "url": "./eig"
+        },
+        {
+            "label": "qr",
+            "url": "./qr"
+        },
+        {
+            "label": "lu",
+            "url": "./lu"
+        },
+        {
+            "label": "chol",
+            "url": "./chol"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        }
+    ],
+    "source": {
+        "label": "crates/runmat-runtime/src/builtins/math/linalg/factor/svd.rs",
+        "url": "crates/runmat-runtime/src/builtins/math/linalg/factor/svd.rs"
+    },
+    "gpu_behavior": [
+        "RunMat reserves a dedicated `svd` provider hook; once a backend implements it, the factors can stay on the device as `gpuTensor` handles without round-tripping through host memory.",
+        "Today no provider ships that hook, so `gpuArray` inputs are gathered to the host, the CPU SVD executes, and the factors are returned as host tensors. You can re-establish residency with `gpuArray(s)` if you need to continue on the GPU.",
+        "Because SVD is a residency sink, the fusion planner treats it as a barrier—preceding GPU tensors are gathered and subsequent ops run on the host unless you manually promote them again."
+    ],
+    "key": "svd",
+    "slug": "svd",
+    "categoryPath": [
+        "math",
+        "linalg",
+        "factor"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=svd.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"svd.js","sourceRoot":"","sources":["../../../src/generated/builtins/svd.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,KAAK;IACd,UAAU,EAAE,oBAAoB;IAChC,UAAU,EAAE;QACV,KAAK;QACL,8BAA8B;QAC9B,QAAQ;QACR,SAAS;QACT,QAAQ;QACR,KAAK;KACN;IACD,SAAS,EAAE,wEAAwE;IACnF,YAAY,EAAE,EAAE;IAChB,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uGAAuG;KACjH;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,4CAA4C;QACpD,aAAa,EAAE,2EAA2E;KAC3F;IACD,aAAa,EAAE,kRAAkR;IACjS,WAAW,EAAE;QACX,uGAAuG;QACvG,kKAAkK;QAClK,qKAAqK;QACrK,0JAA0J;QAC1J,mFAAmF;QACnF,iIAAiI;QACjI,0GAA0G;KAC3G;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,wCAAwC;SAClD;QACD;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,0DAA0D;SACpE;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,mGAAmG;SAC7G;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,mGAAmG;SAC7G;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,8CAA8C;SACxD;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,4CAA4C;SACtD;QACD;YACE,aAAa,EAAE,+DAA+D;YAC9E,OAAO,EAAE,kGAAkG;SAC5G;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,2KAA2K;SACtL;QACD;YACE,UAAU,EAAE,wDAAwD;YACpE,QAAQ,EAAE,uTAAuT;SAClU;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,4LAA4L;SACvM;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,qKAAqK;SAChL;QACD;YACE,UAAU,EAAE,8CAA8C;YAC1D,QAAQ,EAAE,qLAAqL;SAChM;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,iNAAiN;SAC5N;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,qOAAqO;SAChP;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,IAAI;YACb,KAAK,EAAE,MAAM;SACd;QACD;YACE,OAAO,EAAE,IAAI;YACb,KAAK,EAAE,MAAM;SACd;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,8DAA8D;QACvE,KAAK,EAAE,8DAA8D;KACtE;IACD,cAAc,EAAE;QACd,sLAAsL;QACtL,6OAA6O;QAC7O,0LAA0L;KAC3L;IACD,KAAK,EAAE,KAAK;IACZ,MAAM,EAAE,KAAK;IACb,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;QACR,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/symrcm.js

@@ -0,0 +1,134 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "symrcm",
+    "category": "math/linalg/structure",
+    "keywords": [
+        "symrcm",
+        "reverse cuthill-mckee",
+        "bandwidth reduction",
+        "symmetric ordering",
+        "permutation",
+        "gpu"
+    ],
+    "summary": "Compute the symmetric reverse Cuthill-McKee permutation that reduces matrix bandwidth.",
+    "references": [
+        "Alan George and Joseph W. Liu, 'Computer Solution of Large Sparse Positive Definite Systems', Prentice Hall, 1981."
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Acceleration providers may implement the `sym_rcm` hook. The WGPU backend currently downloads the matrix, runs the host algorithm, and returns the permutation."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::linalg::structure::symrcm::tests",
+        "integration": "builtins::math::linalg::structure::symrcm::tests::symrcm_gpu_roundtrip"
+    },
+    "description": "`r = symrcm(A)` returns a permutation vector that reorders a symmetric (or structurally symmetric) matrix to reduce its bandwidth. You can use the permutation as `A(r, r)` to obtain a matrix with a tighter band structure, which improves factorisation and linear solve performance for sparse matrices.",
+    "behaviors": [
+        "Treats the input as an undirected graph based on the pattern of `A + A'`. Any value that is not exactly zero (including `NaN` or `Inf`) creates an edge; diagonal entries are ignored because they do not affect bandwidth.",
+        "Accepts numeric, logical, and complex matrices. Logical and integer inputs are promoted to double precision internally, and complex entries are considered nonzero when either the real or imaginary component is nonzero.",
+        "Requires a square matrix (scalars and the empty matrix are allowed). Inputs with more than two non-singleton dimensions raise an error, matching MATLAB matrix semantics.",
+        "Processes disconnected components independently. Each component starts from a minimum degree vertex, runs a Cuthill-McKee breadth-first search, and the component ordering is reversed to produce the symmetric variant.",
+        "Returns a row vector of 1-based indices. Fully diagonal or zero matrices produce the identity permutation."
+    ],
+    "examples": [
+        {
+            "description": "Reducing bandwidth of a near-band matrix",
+            "input": "A = [4 1 0 0 2;\n     1 4 1 0 0;\n     0 1 4 1 0;\n     0 0 1 4 1;\n     2 0 0 1 4];\nr = symrcm(A);\nB = A(r, r);\nbandwidth(A)\nbandwidth(B)"
+        },
+        {
+            "description": "Handling disconnected components with `symrcm`",
+            "input": "A = [1 1 0 0 0;\n     1 1 0 0 0;\n     0 0 1 0 1;\n     0 0 0 1 1;\n     0 0 1 1 1];\nr = symrcm(A);\nB = A(r, r)"
+        },
+        {
+            "description": "Using `symrcm` with logical adjacency matrices",
+            "input": "adj = logical([0 1 0 0;\n               1 0 1 0;\n               0 1 0 1;\n               0 0 1 0]);\nr = symrcm(adj)"
+        },
+        {
+            "description": "Applying `symrcm` to GPU matrices",
+            "input": "G = gpuArray([0 1 0 0 2;\n              1 0 1 0 0;\n              0 1 0 1 0;\n              0 0 1 0 1;\n              2 0 0 1 0]);\nr = symrcm(G);\nH = gather(G(r, r))"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What class of matrices benefit from `symrcm`?",
+            "answer": "Any symmetric (or structurally symmetric) sparse matrix whose bandwidth dominates solver cost, such as discretised PDE operators, circuit matrices, or graph Laplacians."
+        },
+        {
+            "question": "Does `symrcm` modify the matrix?",
+            "answer": "No. It returns a permutation vector. Apply it as `A(r, r)` or reorder vectors with `x(r)`."
+        },
+        {
+            "question": "What happens if the matrix is not symmetric?",
+            "answer": "RunMat mirrors MATLAB and forms the pattern of `A + A'` internally. As long as the matrix has symmetric nonzero structure, `symrcm` works. Strongly asymmetric inputs may lead to less effective orderings but still produce a valid permutation."
+        },
+        {
+            "question": "Are diagonal entries considered?",
+            "answer": "Diagonal entries are ignored when building the graph. Only off-diagonal nonzeros contribute edges, which aligns with MATLAB semantics."
+        },
+        {
+            "question": "How are NaNs or Infs handled?",
+            "answer": "Any value that is not numerically equal to zero is treated as nonzero, including `NaN` or `Inf`. This matches MATLAB's structural interpretation."
+        },
+        {
+            "question": "Can I use `symrcm` on dense matrices?",
+            "answer": "Yes. Dense inputs are supported. For dense matrices, the result is typically the identity permutation because all vertices have high degree."
+        },
+        {
+            "question": "How do I verify the permutation improves bandwidth?",
+            "answer": "Compute `bandwidth(A)` and `bandwidth(A(r, r))` and compare the results. Lower lower/upper bandwidth values indicate a tighter band and more efficient factorizations."
+        },
+        {
+            "question": "What output shape should I expect?",
+            "answer": "The permutation is returned as a row vector (`1 × n`). The empty matrix returns the empty row vector `[]`."
+        }
+    ],
+    "links": [
+        {
+            "label": "bandwidth",
+            "url": "./bandwidth"
+        },
+        {
+            "label": "issymmetric",
+            "url": "./issymmetric"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "ishermitian",
+            "url": "./ishermitian"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/linalg/structure/symrcm.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/linalg/structure/symrcm.rs"
+    },
+    "gpu_residency": "No. The runtime gathers GPU matrices automatically when computing the permutation today. When native GPU implementations land, the same builtin will run entirely on the device without code changes. You can still call `gpuArray` explicitly to mirror MATLAB workflows, but it is optional in RunMat.",
+    "gpu_behavior": [
+        "RunMat first asks the active acceleration provider whether it implements the `sym_rcm` hook. The WGPU backend exposes this hook today and downloads the matrix once to reuse the optimised CPU algorithm before returning the permutation. Providers without support (or those that report an error) trigger an automatic gather and reuse the host implementation, so results stay correct regardless of GPU capabilities."
+    ],
+    "key": "symrcm",
+    "slug": "symrcm",
+    "categoryPath": [
+        "math",
+        "linalg",
+        "structure"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=symrcm.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"symrcm.js","sourceRoot":"","sources":["../../../src/generated/builtins/symrcm.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,uBAAuB;IACnC,UAAU,EAAE;QACV,QAAQ;QACR,uBAAuB;QACvB,qBAAqB;QACrB,oBAAoB;QACpB,aAAa;QACb,KAAK;KACN;IACD,SAAS,EAAE,wFAAwF;IACnG,YAAY,EAAE;QACZ,oHAAoH;KACrH;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,iKAAiK;KAC3K;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,kDAAkD;QAC1D,aAAa,EAAE,wEAAwE;KACxF;IACD,aAAa,EAAE,8SAA8S;IAC7T,WAAW,EAAE;QACX,6NAA6N;QAC7N,4NAA4N;QAC5N,2KAA2K;QAC3K,0NAA0N;QAC1N,4GAA4G;KAC7G;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,gJAAgJ;SAC1J;QACD;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,mHAAmH;SAC7H;QACD;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,uHAAuH;SACjI;QACD;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,yKAAyK;SACnL;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,0KAA0K;SACrL;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,4FAA4F;SACvG;QACD;YACE,UAAU,EAAE,8CAA8C;YAC1D,QAAQ,EAAE,mPAAmP;SAC9P;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,wIAAwI;SACnJ;QACD;YACE,UAAU,EAAE,+BAA+B;YAC3C,QAAQ,EAAE,mJAAmJ;SAC9J;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,8IAA8I;SACzJ;QACD;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,wKAAwK;SACnL;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,4GAA4G;SACvH;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,aAAa;YACtB,KAAK,EAAE,eAAe;SACvB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,aAAa;YACtB,KAAK,EAAE,eAAe;SACvB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,sEAAsE;QAC/E,KAAK,EAAE,mHAAmH;KAC3H;IACD,eAAe,EAAE,0SAA0S;IAC3T,cAAc,EAAE;QACd,6ZAA6Z;KAC9Z;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;QACR,WAAW;KACZ;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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