runmat 0.4.9-dev.1 → 0.4.9

package/dist/generated/builtins/mode.js

@@ -0,0 +1,146 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "mode",
+    "category": "stats/summary",
+    "keywords": [
+        "mode",
+        "frequency",
+        "statistics",
+        "reduction",
+        "ties"
+    ],
+    "summary": "Most frequent value along a dimension with MATLAB-compatible tie semantics.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Mode currently executes on the host; GPU tensors are gathered to the CPU before computing the result."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::stats::summary::mode::tests"
+    },
+    "description": "`mode(A)` returns the value that appears most frequently in `A`. When multiple values share the same maximum frequency, the smallest tied value is returned in `M`, matching MATLAB. Requesting `[M, F, C] = mode(A)` additionally yields the frequency of the mode and a cell array `C` whose entries are sorted column vectors of the tied values for each slice.",
+    "behaviors": [
+        "`mode(A)` reduces along the first non-singleton dimension of `A`.",
+        "`mode(A, dim)` reduces along the specified dimension (1-based, `>= 1`).",
+        "`mode(A, 'all')` collapses every element of `A` into a single scalar mode.",
+        "`[M, F, C] = mode(A, ...)` additionally returns the frequency `F` of the mode (as a double) and a cell array `C` of sorted tied values per slice.",
+        "Ties resolve to the smallest tied value in `M`, while `C` contains the full tied set sorted in ascending order.",
+        "NaN entries are ignored. If a slice is entirely `NaN` (or empty), the corresponding `M` value is `NaN`, `F` is `0`, and the cell entry is an empty `0 × 1` column.",
+        "Logical, integer, and boolean inputs are promoted to double precision before counting frequencies.",
+        "Dimensions larger than `ndims(A)` treat the input as having trailing singleton dimensions, so each slice contains a single element."
+    ],
+    "examples": [
+        {
+            "description": "Mode of a vector with a clear majority",
+            "input": "x = [1 2 2 3 3 3 4];\nm = mode(x)",
+            "output": "m = 3"
+        },
+        {
+            "description": "Ties return the smallest value with the full sorted set",
+            "input": "x = [1 1 2 2];\n[m, f, c] = mode(x)",
+            "output": "m = 1\nf = 2\nc = {[1; 2]}"
+        },
+        {
+            "description": "Column-wise mode of a matrix",
+            "input": "A = [1 2 1; 2 2 3; 2 4 3];\nm = mode(A)",
+            "output": "m = [2 2 3]"
+        },
+        {
+            "description": "Mode along the second dimension",
+            "input": "A = [1 2 1; 2 2 3; 2 4 3];\nm = mode(A, 2)",
+            "output": "m = [1; 2; 2]"
+        },
+        {
+            "description": "Mode across every element",
+            "input": "A = [1 2 3; 2 3 2];\nm = mode(A, 'all')",
+            "output": "m = 2"
+        },
+        {
+            "description": "NaN values are ignored unless every element is NaN",
+            "input": "x = [1 NaN 2 2 NaN];\n[m, f] = mode(x)",
+            "output": "m = 2\nf = 2"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How are ties resolved?",
+            "answer": "`M` returns the smallest value among the tied set. The third output `C` contains every tied value sorted in ascending order as a column vector."
+        },
+        {
+            "question": "What happens with NaN values?",
+            "answer": "NaN entries are skipped while counting frequencies. If a slice is entirely NaN, RunMat returns `NaN` for the mode, `0` for the frequency, and an empty `0 × 1` column in the cell array."
+        },
+        {
+            "question": "Does mode support logical or integer inputs?",
+            "answer": "Yes. Logical and integer arrays are promoted to double precision before counting, matching MATLAB."
+        },
+        {
+            "question": "Can I reduce across all elements of an array?",
+            "answer": "Use `mode(A, 'all')` to collapse every element of `A` into a single scalar."
+        },
+        {
+            "question": "Does mode execute on the GPU?",
+            "answer": "Not today. GPU tensors are gathered to the host so the result remains bit-for-bit MATLAB compatible; future providers may expose dedicated mode kernels."
+        }
+    ],
+    "links": [
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "median",
+            "url": "./median"
+        },
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "std",
+            "url": "./std"
+        },
+        {
+            "label": "var",
+            "url": "./var"
+        },
+        {
+            "label": "histcounts",
+            "url": "./histcounts"
+        },
+        {
+            "label": "unique",
+            "url": "./unique"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/stats/summary/mode.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/stats/summary/mode.rs"
+    },
+    "key": "mode",
+    "slug": "mode",
+    "aliases": [],
+    "categoryPath": [
+        "stats",
+        "summary"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=mode.js.map

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

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

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

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

package/dist/generated/builtins/optimset.js

@@ -11,7 +11,7 @@ const builtinDoc = {
         "MaxIter",
         "Display"
     ],
-    "summary": "Create or update an optimization options structure for fzero and fsolve.",
+    "summary": "Create or update an optimization options structure for fminbnd, fzero, and fsolve.",
     "references": [
         "https://www.mathworks.com/help/matlab/ref/optimset.html"
     ],
@@ -32,7 +32,7 @@ const builtinDoc = {
     "tested": {
         "unit": "builtins::math::optim::optimset::tests"
     },
-    "description": "`opts = optimset(name, value, ...)` creates a struct of optimization options. `opts = optimset(old, name, value, ...)` copies an existing options struct and applies overrides.",
+    "description": "`opts = optimset(name, value, ...)` creates a struct of optimization options. `opts = optimset(old, name, value, ...)` copies an existing options struct and applies overrides. The resulting struct can be passed to optimization builtins such as `fminbnd`, `fzero`, and `fsolve`.",
     "behaviors": [
         "Option names are case-insensitive for the builtins that consume them.",
         "`TolX`, `TolFun`, `MaxIter`, `MaxFunEvals`, and `Display` are canonicalized when constructed with `optimset`.",
@@ -40,12 +40,16 @@ const builtinDoc = {
     ],
     "examples": [
         {
-            "description": "Create options for fzero",
-            "input": "opts = optimset('TolX', 1e-10, 'Display', 'off');\nx = fzero(@sin, [3 4], opts)",
+            "description": "Create options for fminbnd",
+            "input": "opts = optimset('TolX', 1e-10, 'Display', 'off');\nx = fminbnd(@cos, 0, pi, opts)",
             "output": "x =\n    3.1416"
         }
     ],
     "links": [
+        {
+            "label": "fminbnd",
+            "url": "./fminbnd"
+        },
         {
             "label": "fzero",
             "url": "./fzero"

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

@@ -1 +1 @@
-{"version":3,"file":"optimset.js","sourceRoot":"","sources":["../../../src/generated/builtins/optimset.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE;QACV,UAAU;QACV,SAAS;QACT,MAAM;QACN,QAAQ;QACR,SAAS;QACT,SAAS;KACV;IACD,SAAS,EAAE,0EAA0E;IACrF,YAAY,EAAE;QACZ,yDAAyD;KAC1D;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,4BAA4B;KACtC;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,wCAAwC;KACjD;IACD,aAAa,EAAE,iLAAiL;IAChM,WAAW,EAAE;QACX,uEAAuE;QACvE,+GAA+G;QAC/G,qEAAqE;KACtE;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,0BAA0B;YACzC,OAAO,EAAE,iFAAiF;YAC1F,QAAQ,EAAE,iBAAiB;SAC5B;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,6DAA6D;QACtE,KAAK,EAAE,0GAA0G;KAClH;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"optimset.js","sourceRoot":"","sources":["../../../src/generated/builtins/optimset.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE;QACV,UAAU;QACV,SAAS;QACT,MAAM;QACN,QAAQ;QACR,SAAS;QACT,SAAS;KACV;IACD,SAAS,EAAE,oFAAoF;IAC/F,YAAY,EAAE;QACZ,yDAAyD;KAC1D;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,4BAA4B;KACtC;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,wCAAwC;KACjD;IACD,aAAa,EAAE,uRAAuR;IACtS,WAAW,EAAE;QACX,uEAAuE;QACvE,+GAA+G;QAC/G,qEAAqE;KACtE;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,4BAA4B;YAC3C,OAAO,EAAE,mFAAmF;YAC5F,QAAQ,EAAE,iBAAiB;SAC5B;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,6DAA6D;QACtE,KAAK,EAAE,0GAA0G;KAClH;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/patch.js

@@ -0,0 +1,135 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "patch",
+    "category": "plotting",
+    "keywords": [
+        "patch",
+        "polygon",
+        "filled polygon",
+        "faces",
+        "vertices",
+        "matlab patch",
+        "graphics primitive"
+    ],
+    "summary": "Create MATLAB-compatible colored polygon patch objects from coordinate data or Faces/Vertices definitions.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`patch` is a plotting sink. The initial implementation gathers GPU-resident coordinate inputs, triangulates polygon faces on the host, then renders through RunMat's shared GPU plotting renderer."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 4,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::patch::tests",
+        "integration": "runmat-plot/src/plots/patch.rs"
+    },
+    "description": "`patch` creates filled polygon graphics objects. RunMat supports practical MATLAB forms including `patch(X,Y,C)`, `patch(X,Y,Z,C)`, name-value `XData`/`YData`/`ZData`, `Faces`/`Vertices`, struct input, explicit axes handles, and common face, edge, alpha, line-width, display-name, and visibility properties.",
+    "behaviors": [
+        "Vector coordinate inputs create one polygon.",
+        "Matrix coordinate inputs create one polygon per column.",
+        "Patch edges close automatically, matching MATLAB's open-polygon behavior.",
+        "`Faces` values are interpreted as MATLAB-style one-based vertex indices.",
+        "2-D vertices are accepted as N-by-2; 3-D vertices are accepted as N-by-3.",
+        "The returned value is a patch graphics handle that works with `get`, `set`, `ishandle`, and `isgraphics`.",
+        "Per-vertex or per-face `CData` colormap interpolation is not yet implemented; non-scalar color data is accepted only as compatibility input and currently falls back to the default face color unless `FaceColor` supplies a concrete RGB/color-name value."
+    ],
+    "options": [
+        "`FaceColor` accepts color names, RGB triples, `flat`, or `none`.",
+        "`EdgeColor` accepts color names, RGB triples, or `none`.",
+        "`FaceAlpha` and `EdgeAlpha` accept numeric values from 0 to 1.",
+        "`LineWidth`, `DisplayName`, and `Visible` use the shared plotting property model.",
+        "`FaceColor`, `EdgeColor`, alpha, line width, display name, visibility, `Faces`, `Vertices`, `XData`, `YData`, and `ZData` are the first supported patch property set. Lighting, normals, texture coordinates, and callback properties are deferred."
+    ],
+    "examples": [
+        {
+            "description": "Create a triangle patch",
+            "input": "x = [0 1 0];\ny = [0 0 1];\npatch(x, y, 'red');"
+        },
+        {
+            "description": "Create two rectangle patches from matrix columns",
+            "input": "X = [0 2; 1 3; 1 3; 0 2];\nY = [0 0; 0 0; 1 1; 1 1];\npatch(X, Y, 'cyan', 'EdgeColor', 'black');"
+        },
+        {
+            "description": "Create a patch from Faces and Vertices",
+            "input": "V = [0 0; 1 0; 1 1; 0 1];\nF = [1 2 3 4];\nh = patch('Faces', F, 'Vertices', V, 'FaceColor', [0.2 0.6 0.9]);\nget(h, 'Type')",
+            "output": "ans =\n    'patch'"
+        },
+        {
+            "description": "Create a 3-D patch",
+            "input": "V = [0 0 0; 1 0 0; 0.5 1 0.5];\nF = [1 2 3];\npatch('Faces', F, 'Vertices', V, 'FaceAlpha', 0.6);\nview(3);"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does patch close polygons automatically?",
+            "answer": "Yes. You can provide open polygon coordinate lists; RunMat closes the edge loop when rendering the patch."
+        },
+        {
+            "question": "Are Faces indices zero-based or one-based?",
+            "answer": "They are one-based to match MATLAB. `Faces = [1 2 3]` references the first, second, and third rows of `Vertices`."
+        },
+        {
+            "question": "Does patch have a direct GPU-resident geometry path?",
+            "answer": "Not yet. RunMat gathers GPU-resident patch inputs for validation and triangulation, then submits the resulting geometry to the shared GPU renderer. A direct GPU triangulation/packing path can be added later for very large patch meshes."
+        }
+    ],
+    "links": [
+        {
+            "label": "surf",
+            "url": "./surf"
+        },
+        {
+            "label": "plot3",
+            "url": "./plot3"
+        },
+        {
+            "label": "fill",
+            "url": "./fill"
+        },
+        {
+            "label": "get",
+            "url": "./get"
+        },
+        {
+            "label": "set",
+            "url": "./set"
+        },
+        {
+            "label": "Graphics Handles",
+            "url": "/docs/plotting/graphics-handles"
+        },
+        {
+            "label": "Plot replay and export",
+            "url": "/docs/plotting/plot-replay-and-export"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/patch.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/patch.rs"
+    },
+    "gpu_residency": "`patch` gathers GPU-resident coordinate inputs in the first implementation because MATLAB-compatible patch parsing requires shape validation, one-based Faces handling, NaN padding, and polygon triangulation. The rendered geometry still flows through the shared GPU plotting renderer.",
+    "gpu_behavior": [
+        "Patch rendering is a plotting sink and fusion barrier.",
+        "Host and gathered-GPU inputs produce the same graphics object and handle behavior.",
+        "A future direct GPU path should preserve the same Faces/Vertices semantics and only replace the triangulation/packing step."
+    ],
+    "key": "patch",
+    "slug": "patch",
+    "aliases": [],
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=patch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"patch.js","sourceRoot":"","sources":["../../../src/generated/builtins/patch.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,SAAS;QACT,gBAAgB;QAChB,OAAO;QACP,UAAU;QACV,cAAc;QACd,oBAAoB;KACrB;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,oMAAoM;KAC9M;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;QAC1C,aAAa,EAAE,gCAAgC;KAChD;IACD,aAAa,EAAE,qTAAqT;IACpU,WAAW,EAAE;QACX,8CAA8C;QAC9C,yDAAyD;QACzD,2EAA2E;QAC3E,0EAA0E;QAC1E,2EAA2E;QAC3E,2GAA2G;QAC3G,6PAA6P;KAC9P;IACD,SAAS,EAAE;QACT,kEAAkE;QAClE,0DAA0D;QAC1D,gEAAgE;QAChE,mFAAmF;QACnF,qPAAqP;KACtP;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,iDAAiD;SAC3D;QACD;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,kGAAkG;SAC5G;QACD;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,8HAA8H;YACvI,QAAQ,EAAE,oBAAoB;SAC/B;QACD;YACE,aAAa,EAAE,oBAAoB;YACnC,OAAO,EAAE,6GAA6G;SACvH;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,2GAA2G;SACtH;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,mHAAmH;SAC9H;QACD;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,6OAA6O;SACxP;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,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,kBAAkB;YAC3B,KAAK,EAAE,iCAAiC;SACzC;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,4DAA4D;QACrE,KAAK,EAAE,yGAAyG;KACjH;IACD,eAAe,EAAE,6RAA6R;IAC9S,cAAc,EAAE;QACd,wDAAwD;QACxD,oFAAoF;QACpF,6HAA6H;KAC9H;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/repelem.js

@@ -0,0 +1,135 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "repelem",
+    "category": "array/shape",
+    "keywords": [
+        "repelem",
+        "replicate",
+        "repeat",
+        "array",
+        "cell"
+    ],
+    "summary": "Replicate each element of an array along one or more dimensions.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "GPU inputs are gathered to host memory before replication; no provider hook exists yet."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::shape::repelem::tests",
+        "integration": "crates/runmat-runtime/tests/nd_ops.rs"
+    },
+    "description": "`repelem(A, r1, r2, ..., rN)` repeats each element of `A` along the requested dimensions. Unlike `repmat`, which tiles whole arrays, `repelem` expands individual elements into runs or blocks.",
+    "behaviors": [
+        "`repelem(v, n)` repeats each element of a row or column vector `v` `n` times and preserves vector orientation.",
+        "`repelem(v, counts)` accepts a count vector with one non-negative integer count per element of `v`.",
+        "`repelem(A, r1, r2, ..., rN)` repeats matrix or N-D array elements along each dimension; scalar factors create element blocks and vector factors provide per-index counts for that dimension.",
+        "Numeric, logical, complex, string, char, and cell inputs are supported. Numeric, logical, complex, string, and cell arrays support N-D replication; char arrays are represented as 2-D character matrices.",
+        "Zero counts are allowed and remove the corresponding element or dimension slice from the output.",
+        "Replication counts must be finite, non-negative integers. Count vectors must match the size of the dimension they apply to.",
+        "The builtin checks shape and size overflow before materializing output arrays."
+    ],
+    "examples": [
+        {
+            "description": "Repeating every element of a row vector",
+            "input": "u = repelem([1 2 3], 2)",
+            "output": "u =\n     1     1     2     2     3     3"
+        },
+        {
+            "description": "Using a per-element count vector",
+            "input": "u = repelem([1 2 3], [1 2 3])",
+            "output": "u =\n     1     2     2     3     3     3"
+        },
+        {
+            "description": "Expanding a matrix into element blocks",
+            "input": "A = [1 2; 3 4];\nB = repelem(A, 2, 3)",
+            "output": "B =\n     1     1     1     2     2     2\n     1     1     1     2     2     2\n     3     3     3     4     4     4\n     3     3     3     4     4     4"
+        },
+        {
+            "description": "Dropping elements with zero counts",
+            "input": "u = repelem([1 2 3 4 5], [0 1 0 2 1])",
+            "output": "u =\n     2     4     4     5"
+        },
+        {
+            "description": "Repeating along a higher dimension",
+            "input": "C = {1; 2};\nD = repelem(reshape(C, [1 1 2]), 1, 1, 2);\nsize(D)",
+            "output": "ans =\n     1     1     4"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How is `repelem` different from `repmat`?",
+            "answer": "`repmat` tiles a whole array. `repelem` repeats each individual element, so matrix inputs expand into element-wise blocks."
+        },
+        {
+            "question": "Can counts be different for each element?",
+            "answer": "Yes. In vector form, the count vector must have one entry for each vector element. In multi-dimensional form, a count vector applies to the dimension at the same argument position."
+        },
+        {
+            "question": "Are zero counts valid?",
+            "answer": "Yes. A zero count omits that element or dimension index from the output."
+        },
+        {
+            "question": "Does `repelem` preserve row and column vector orientation?",
+            "answer": "Yes. Row vectors remain row vectors, column vectors remain column vectors, including empty column vectors."
+        },
+        {
+            "question": "Does `repelem` run on the GPU?",
+            "answer": "Not yet. The runtime gathers GPU tensors to host memory for this builtin, computes the replicated result on the CPU, and returns a host value."
+        }
+    ],
+    "links": [
+        {
+            "label": "repmat",
+            "url": "./repmat"
+        },
+        {
+            "label": "kron",
+            "url": "./kron"
+        },
+        {
+            "label": "reshape",
+            "url": "./reshape"
+        },
+        {
+            "label": "cat",
+            "url": "./cat"
+        },
+        {
+            "label": "size",
+            "url": "./size"
+        }
+    ],
+    "source": {
+        "label": "crates/runmat-runtime/src/builtins/array/shape/repelem.rs",
+        "url": "crates/runmat-runtime/src/builtins/array/shape/repelem.rs"
+    },
+    "gpu_residency": "`repelem` is currently a host-resident array construction builtin. If a GPU tensor reaches this builtin, RunMat gathers it before replication.",
+    "gpu_behavior": [
+        "RunMat does not yet expose a provider hook for element-wise replication. Backends can add one later without changing the MATLAB-facing behavior."
+    ],
+    "extended_capabilities": [
+        "`repelem` preserves the input value class for numeric dtype metadata, logical arrays, complex tensors, string arrays, char arrays, and cell arrays.",
+        "N-D numeric, logical, complex, string, and cell replication uses the runtime's native storage order for each value kind."
+    ],
+    "key": "repelem",
+    "slug": "repelem",
+    "aliases": [],
+    "categoryPath": [
+        "array",
+        "shape"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=repelem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"repelem.js","sourceRoot":"","sources":["../../../src/generated/builtins/repelem.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,SAAS;QACT,WAAW;QACX,QAAQ;QACR,OAAO;QACP,MAAM;KACP;IACD,SAAS,EAAE,kEAAkE;IAC7E,YAAY,EAAE,EAAE;IAChB,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,yFAAyF;KACnG;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,wCAAwC;QAChD,aAAa,EAAE,uCAAuC;KACvD;IACD,aAAa,EAAE,iMAAiM;IAChN,WAAW,EAAE;QACX,gHAAgH;QAChH,qGAAqG;QACrG,+LAA+L;QAC/L,4MAA4M;QAC5M,kGAAkG;QAClG,6HAA6H;QAC7H,gFAAgF;KACjF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,yBAAyB;YAClC,QAAQ,EAAE,2CAA2C;SACtD;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,+BAA+B;YACxC,QAAQ,EAAE,2CAA2C;SACtD;QACD;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,uCAAuC;YAChD,QAAQ,EAAE,6JAA6J;SACxK;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,uCAAuC;YAChD,QAAQ,EAAE,+BAA+B;SAC1C;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,kEAAkE;YAC3E,QAAQ,EAAE,2BAA2B;SACtC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,4HAA4H;SACvI;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,sLAAsL;SACjM;QACD;YACE,UAAU,EAAE,wBAAwB;YACpC,QAAQ,EAAE,0EAA0E;SACrF;QACD;YACE,UAAU,EAAE,4DAA4D;YACxE,QAAQ,EAAE,4GAA4G;SACvH;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,gJAAgJ;SAC3J;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,2DAA2D;KACnE;IACD,eAAe,EAAE,gJAAgJ;IACjK,cAAc,EAAE;QACd,kJAAkJ;KACnJ;IACD,uBAAuB,EAAE;QACvB,qJAAqJ;QACrJ,0HAA0H;KAC3H;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/sawtooth.js

@@ -0,0 +1,111 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "sawtooth",
+    "category": "math/signal",
+    "keywords": [
+        "sawtooth",
+        "waveform",
+        "signal processing",
+        "triangle",
+        "periodic",
+        "elementwise"
+    ],
+    "summary": "Generate a periodic sawtooth waveform with optional peak position.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f64"
+        ],
+        "broadcasting": "elementwise",
+        "notes": "GPU inputs are gathered to the host so the reference implementation can guarantee MATLAB-compatible piecewise-linear evaluation at the period boundary."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline",
+        "notes": "Fusion is intentionally disabled for v1 because the WGSL piecewise expression is non-trivial and brings little benefit relative to the host loop."
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::signal::sawtooth::tests",
+        "integration": null
+    },
+    "description": "`y = sawtooth(t)` generates a sawtooth wave with period `2*pi` at the sample times in `t`, ranging in `[-1, 1]`. `y = sawtooth(t, xmax)` controls the peak position with `xmax` in `[0, 1]`: `xmax = 1` (the default) produces a rising sawtooth, `xmax = 0` produces a falling sawtooth, and intermediate values such as `xmax = 0.5` produce a triangle wave whose peak is at the centre of each period.",
+    "behaviors": [
+        "Operates element-wise on scalars, vectors, matrices, and N-D tensors; preserves input shape.",
+        "Reduces input modulo `2*pi` so the waveform is periodic across negative and positive sample times.",
+        "Returns `-1` at the start of each period and approaches `+1` just before the period boundary wraps when `xmax = 1`.",
+        "Returns a piecewise-linear triangle wave when `xmax = 0.5`, peaking at `1` at the centre of each period.",
+        "Returns a pure falling ramp when `xmax = 0` and a pure rising ramp when `xmax = 1`.",
+        "Integer and logical inputs are promoted to double precision before evaluation.",
+        "Non-finite sample times (`NaN`, `+Inf`, `-Inf`) propagate as `NaN` element-wise, matching MATLAB.",
+        "Complex and text inputs are rejected with a builtin-scoped error.",
+        "Rejects `xmax` values outside `[0, 1]` and non-scalar `xmax` arguments."
+    ],
+    "examples": [
+        {
+            "description": "Default rising sawtooth over two periods",
+            "input": "t = 0:pi/2:4*pi;\ny = sawtooth(t)",
+            "output": "y = [-1 -0.5 0 0.5 -1 -0.5 0 0.5 -1]"
+        },
+        {
+            "description": "Triangle wave via xmax = 0.5",
+            "input": "t = linspace(0, 2*pi, 5);\ny = sawtooth(t, 0.5)",
+            "output": "y = [-1 0 1 0 -1]"
+        },
+        {
+            "description": "Pure falling sawtooth via xmax = 0",
+            "input": "y = sawtooth([0 pi 2*pi], 0)",
+            "output": "y = [1 0 1]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why does `sawtooth(2*pi)` return `-1` instead of `+1`?",
+            "answer": "RunMat reduces the input modulo `2*pi`, so `2*pi` is folded back to the start of the next period. The default rising sawtooth therefore restarts at `-1` exactly on each period boundary, matching MATLAB."
+        },
+        {
+            "question": "How do I produce a triangle wave?",
+            "answer": "Pass `xmax = 0.5` so the peak sits at the centre of each period and the waveform ramps symmetrically up and back down."
+        },
+        {
+            "question": "Can `sawtooth` accept complex inputs?",
+            "answer": "No. `sawtooth` is defined on real samples and rejects complex inputs with a builtin-scoped error to match MATLAB."
+        }
+    ],
+    "links": [
+        {
+            "label": "square",
+            "url": "./square"
+        },
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "cos",
+            "url": "./cos"
+        },
+        {
+            "label": "linspace",
+            "url": "./linspace"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/signal/sawtooth.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/signal/sawtooth.rs"
+    },
+    "key": "sawtooth",
+    "slug": "sawtooth",
+    "aliases": [],
+    "categoryPath": [
+        "math",
+        "signal"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=sawtooth.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sawtooth.js","sourceRoot":"","sources":["../../../src/generated/builtins/sawtooth.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,UAAU;QACV,UAAU;QACV,mBAAmB;QACnB,UAAU;QACV,UAAU;QACV,aAAa;KACd;IACD,SAAS,EAAE,oEAAoE;IAC/E,YAAY,EAAE,EAAE;IAChB,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,aAAa;QAC7B,OAAO,EAAE,yJAAyJ;KACnK;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;QACrB,OAAO,EAAE,mJAAmJ;KAC7J;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,yCAAyC;QACjD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,4YAA4Y;IAC3Z,WAAW,EAAE;QACX,8FAA8F;QAC9F,oGAAoG;QACpG,qHAAqH;QACrH,0GAA0G;QAC1G,qFAAqF;QACrF,gFAAgF;QAChF,mGAAmG;QACnG,mEAAmE;QACnE,yEAAyE;KAC1E;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,mCAAmC;YAC5C,QAAQ,EAAE,sCAAsC;SACjD;QACD;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,iDAAiD;YAC1D,QAAQ,EAAE,mBAAmB;SAC9B;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,8BAA8B;YACvC,QAAQ,EAAE,aAAa;SACxB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,wDAAwD;YACpE,QAAQ,EAAE,4MAA4M;SACvN;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,wHAAwH;SACnI;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,mHAAmH;SAC9H;KACF;IACD,OAAO,EAAE;QACP;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;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,8DAA8D;QACvE,KAAK,EAAE,2GAA2G;KACnH;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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