runmat 0.4.9-dev.1 → 0.4.9

package/dist/generated/builtins/fill3.js

@@ -0,0 +1,152 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "fill3",
+    "category": "plotting",
+    "keywords": [
+        "fill3",
+        "3-D filled polygon",
+        "patch",
+        "polygon",
+        "matlab fill3",
+        "3d patch"
+    ],
+    "summary": "Create MATLAB-compatible filled polygon patches in 3-D space.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`fill3` is a plotting sink. It lowers coordinate and color argument groups to `patch` objects, gathering GPU-resident coordinate inputs through the shared patch path."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 4,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::fill3::tests"
+    },
+    "description": "`fill3` creates filled polygon graphics objects from X, Y, and Z coordinate data. RunMat implements it as a thin wrapper over the shared `patch` machinery, so returned handles are patch graphics handles and common patch name-value properties apply.",
+    "behaviors": [
+        "`fill3(X, Y, Z, C)` creates one or more 3-D filled polygons from matching coordinate arrays.",
+        "Vector coordinate inputs create one polygon.",
+        "Matrix coordinate inputs create one polygon per column through the underlying `patch` parser.",
+        "Multiple `X,Y,Z,C` groups in one call create multiple patch objects and return a row vector of patch handles.",
+        "A single polygon group returns a scalar patch handle.",
+        "`fill3` initializes the target axes with the standard 3-D view, so even polygons in the z=0 plane render as 3-D patch content.",
+        "Trailing patch property name-value pairs are applied to every polygon group in the call.",
+        "The returned patch handles work with `get`, `set`, `ishandle`, and `isgraphics`.",
+        "Color strings and RGB triples are supported through the shared patch color parser.",
+        "Indexed or interpolated CData behavior is currently limited by the underlying `patch` implementation; concrete color strings, RGB triples, and common patch properties are the supported color path."
+    ],
+    "options": [
+        "`FaceColor` accepts color names, RGB triples, `flat`, or `none` through `patch`.",
+        "`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.",
+        "Explicit axes handles are accepted as the leading argument, matching other RunMat plotting builtins."
+    ],
+    "examples": [
+        {
+            "description": "Create a red square in the z=0 plane",
+            "input": "x = [0 1 1 0];\ny = [0 0 1 1];\nz = [0 0 0 0];\nh = fill3(x, y, z, 'r');\nget(h, 'Type')",
+            "output": "ans =\n    'patch'"
+        },
+        {
+            "description": "Create two filled polygons in one call",
+            "input": "x1 = [0 1 0];\ny1 = [0 0 1];\nz1 = [0 0 0];\nx2 = [2 3 3 2];\ny2 = [0 0 1 1];\nz2 = [1 1 1 1];\nh = fill3(x1, y1, z1, 'g', x2, y2, z2, [0 0 1]);"
+        },
+        {
+            "description": "Apply patch properties to a fill3 polygon",
+            "input": "x = [0 1 0];\ny = [0 0 1];\nz = [0.25 0.5 0.75];\nh = fill3(x, y, z, [0.25 0.5 0.75], 'EdgeColor', 'none', 'FaceAlpha', 0.5);"
+        },
+        {
+            "description": "Create one patch per matrix column",
+            "input": "X = [0 2; 1 3; 1 3; 0 2];\nY = [0 0; 0 0; 1 1; 1 1];\nZ = [0 1; 0 1; 0 1; 0 1];\nfill3(X, Y, Z, 'cyan');\nview(3);"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What does fill3 return?",
+            "answer": "`fill3` returns patch graphics handles. A single polygon group returns one scalar handle; multiple groups return a row vector of handles."
+        },
+        {
+            "question": "How is fill3 related to patch?",
+            "answer": "`fill3` lowers its positional `X,Y,Z,C` inputs into the same `patch` object machinery. This keeps geometry validation, color parsing, property handling, rendering, and handle behavior consistent with `patch`."
+        },
+        {
+            "question": "Can I pass patch properties to fill3?",
+            "answer": "Yes. Trailing name-value pairs such as `'EdgeColor', 'none'`, `'FaceAlpha', 0.5`, and `'LineWidth', 2` are forwarded to the patch objects created by `fill3`."
+        },
+        {
+            "question": "Does fill3 support GPU-resident inputs?",
+            "answer": "GPU-resident coordinate inputs are gathered through the shared patch path for validation and polygon construction, then the resulting geometry is rendered through RunMat's GPU plotting renderer."
+        },
+        {
+            "question": "Does fill3 support indexed CData?",
+            "answer": "The current implementation is constrained by `patch`: color strings and RGB triples are supported, while full MATLAB indexed/interpolated CData behavior is deferred."
+        }
+    ],
+    "links": [
+        {
+            "label": "patch",
+            "url": "./patch"
+        },
+        {
+            "label": "plot3",
+            "url": "./plot3"
+        },
+        {
+            "label": "scatter3",
+            "url": "./scatter3"
+        },
+        {
+            "label": "surf",
+            "url": "./surf"
+        },
+        {
+            "label": "view",
+            "url": "./view"
+        },
+        {
+            "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/fill3.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/fill3.rs"
+    },
+    "gpu_residency": "`fill3` is a plotting sink and fusion barrier. GPU-resident coordinate inputs are gathered before patch construction because MATLAB-compatible parsing requires shape validation and polygon assembly.",
+    "gpu_behavior": [
+        "`fill3` shares patch rendering behavior, so host and gathered-GPU coordinate inputs produce the same patch objects and graphics handles.",
+        "Rendered geometry flows through the shared GPU plotting renderer after the patch objects are built.",
+        "A future direct GPU path should preserve the same `X,Y,Z,C` grouping and patch property semantics while replacing only the coordinate gathering and geometry packing stage."
+    ],
+    "key": "fill3",
+    "slug": "fill3",
+    "aliases": [],
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=fill3.js.map

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

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

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

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

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

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

package/dist/generated/builtins/fminbnd.js

@@ -0,0 +1,104 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "fminbnd",
+    "category": "math/optim",
+    "keywords": [
+        "fminbnd",
+        "bounded minimization",
+        "brent",
+        "golden section",
+        "parabolic interpolation",
+        "optimization"
+    ],
+    "summary": "Find a local minimum of a scalar function on a bounded interval using Brent's method.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/fminbnd.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "The solver runs on the host. Callback functions may still call GPU-aware builtins."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 4,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::optim::fminbnd::tests",
+        "integration": "runmat-vm/tests/closures.rs::fminbnd_accepts_anonymous_function"
+    },
+    "description": "`x = fminbnd(fun, x1, x2)` searches the closed interval `[x1, x2]` for a local minimum of the scalar function `fun` using Brent's method (golden-section search combined with parabolic interpolation). Additional output arities expose the function value at the minimum, an exit flag, and a diagnostic struct.",
+    "behaviors": [
+        "The function handle must return a finite real scalar for every sampled point in the interval.",
+        "If `x1 > x2`, the bounds are inconsistent and `exitflag = -2`.",
+        "If `x1 == x2`, that point is returned with `exitflag = 1`.",
+        "Options are supplied as a struct, usually built with `optimset`. `TolX`, `MaxIter`, `MaxFunEvals`, and `Display` are accepted.",
+        "`Display` may be `'off'`, `'iter'`, `'notify'` (default; only prints when the solver fails to converge), or `'final'`.",
+        "`exitflag` is `1` on convergence within `TolX`, `0` when the iteration or evaluation budget is exhausted.",
+        "The fourth output is a struct with `iterations`, `funcCount`, `algorithm`, and `message` fields."
+    ],
+    "examples": [
+        {
+            "description": "Minimize a quadratic",
+            "input": "x = fminbnd(@(x) (x-2).^2, 0, 5)",
+            "output": "x =\n    2.0000"
+        },
+        {
+            "description": "Capture the function value too",
+            "input": "[x, fval] = fminbnd(@(x) (x-3).^2 + 1, 0, 5)",
+            "output": "x =\n    3.0000\nfval =\n    1.0000"
+        },
+        {
+            "description": "Tighten tolerances",
+            "input": "opts = optimset('TolX', 1e-10, 'Display', 'off');\n[x, fval, exitflag] = fminbnd(@cos, 0, pi, opts)",
+            "output": "x =\n    3.1416\nfval =\n   -1.0000\nexitflag =\n     1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does fminbnd support unbounded minimization?",
+            "answer": "No. `fminbnd` requires finite scalar bounds. Use `fminunc` or `fminsearch` for unconstrained problems."
+        },
+        {
+            "question": "Can I retrieve the iteration history?",
+            "answer": "Yes — request the four-output form `[x, fval, exitflag, output] = fminbnd(...)` to receive a struct with `iterations`, `funcCount`, `algorithm`, and `message`."
+        },
+        {
+            "question": "Does fminbnd guarantee a global minimum?",
+            "answer": "No. Brent's method converges to a local minimum on `[x1, x2]`. For multi-modal functions, narrow the interval to bracket the desired minimum."
+        }
+    ],
+    "links": [
+        {
+            "label": "fzero",
+            "url": "./fzero"
+        },
+        {
+            "label": "fsolve",
+            "url": "./fsolve"
+        },
+        {
+            "label": "optimset",
+            "url": "./optimset"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/optim/fminbnd.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/optim/fminbnd.rs"
+    },
+    "key": "fminbnd",
+    "slug": "fminbnd",
+    "aliases": [],
+    "categoryPath": [
+        "math",
+        "optim"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=fminbnd.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fminbnd.js","sourceRoot":"","sources":["../../../src/generated/builtins/fminbnd.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE;QACV,SAAS;QACT,sBAAsB;QACtB,OAAO;QACP,gBAAgB;QAChB,yBAAyB;QACzB,cAAc;KACf;IACD,SAAS,EAAE,uFAAuF;IAClG,YAAY,EAAE;QACZ,wDAAwD;KACzD;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,oFAAoF;KAC9F;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,uCAAuC;QAC/C,aAAa,EAAE,iEAAiE;KACjF;IACD,aAAa,EAAE,oTAAoT;IACnU,WAAW,EAAE;QACX,+FAA+F;QAC/F,gEAAgE;QAChE,4DAA4D;QAC5D,gIAAgI;QAChI,wHAAwH;QACxH,2GAA2G;QAC3G,kGAAkG;KACnG;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,sBAAsB;YACrC,OAAO,EAAE,kCAAkC;YAC3C,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,8CAA8C;YACvD,QAAQ,EAAE,qCAAqC;SAChD;QACD;YACE,aAAa,EAAE,oBAAoB;YACnC,OAAO,EAAE,qGAAqG;YAC9G,QAAQ,EAAE,yDAAyD;SACpE;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,8CAA8C;YAC1D,QAAQ,EAAE,wGAAwG;SACnH;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,iKAAiK;SAC5K;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,+IAA+I;SAC1J;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,4DAA4D;QACrE,KAAK,EAAE,yGAAyG;KACjH;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/impulse.js

@@ -0,0 +1,123 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "impulse",
+    "category": "control",
+    "keywords": [
+        "impulse",
+        "impulse response",
+        "control system",
+        "transfer function",
+        "tf"
+    ],
+    "summary": "Compute or plot the impulse response of supported dynamic system models.",
+    "references": [
+        "title: \"MATLAB impulse documentation\"",
+        "title: \"Octave control package impulse documentation\""
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "`impulse` evaluates host-side control-system metadata and returns host-resident response vectors."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline",
+        "notes": "`impulse` simulates a dynamic system response and terminates fusion chains."
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::control::impulse::tests",
+        "integration": "crates/runmat-vm/tests/control.rs"
+    },
+    "description": "`impulse(sys)` computes the impulse response for real, strictly proper, scalar-input scalar-output `tf` objects. With output arguments it returns numeric response data; when called in a no-output context and plotting is available, it plots the response.",
+    "behaviors": [
+        "Supports real SISO `tf` objects created by `tf(num, den)` or `tf(num, den, Ts)`.",
+        "`impulse(sys)` uses a deterministic default time vector.",
+        "`impulse(sys, tFinal)` generates a deterministic time vector from zero to `tFinal`.",
+        "`impulse(sys, t)` respects an explicit real, finite, non-negative, strictly increasing time vector.",
+        "`[y, t] = impulse(...)` returns `y` and `t` as `N x 1` column vectors for supported SISO systems.",
+        "Continuous-time responses are evaluated from a controllable canonical state-space realization.",
+        "Discrete-time responses respect MATLAB's unit-area impulse convention: the input pulse has height `1/Ts`, and time vectors must use integer multiples of `Ts`.",
+        "Unsupported model classes, delays, complex coefficients, static gains, and non-strictly-proper transfer functions raise clear diagnostics."
+    ],
+    "examples": [
+        {
+            "description": "Compute a first-order impulse response",
+            "input": "H = tf(20, [1 5]);\nt = 0:0.1:1;\n[y, tout] = impulse(H, t);",
+            "output": "y and tout are column vectors."
+        },
+        {
+            "description": "Plot an impulse response",
+            "input": "H = tf(1, [1 3 2]);\nimpulse(H);"
+        },
+        {
+            "description": "Discrete-time impulse response",
+            "input": "H = tf(1, [1 -0.5], 0.1);\n[y, t] = impulse(H, 0:0.1:0.5);"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `impulse` support MIMO systems?",
+            "answer": "Not yet. The current implementation supports real SISO `tf` objects. Broader model-family and MIMO support is tracked separately."
+        },
+        {
+            "question": "Why are non-strictly-proper transfer functions rejected?",
+            "answer": "Those systems include a direct impulse term that is not represented as a finite numeric response vector in the current runtime model."
+        },
+        {
+            "question": "Can I use state-space or zero-pole-gain models?",
+            "answer": "Not yet. `ss`, `zpk`, `frd`, model arrays, and identified-system families are outside this first implementation."
+        }
+    ],
+    "links": [
+        {
+            "label": "tf",
+            "url": "./tf"
+        },
+        {
+            "label": "plot",
+            "url": "./plot"
+        },
+        {
+            "label": "stem",
+            "url": "./stem"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/control/impulse.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/control/impulse.rs"
+    },
+    "syntax": {
+        "example": {
+            "description": "Supported forms",
+            "input": "impulse(sys)\ny = impulse(sys)\n[y, t] = impulse(sys)\n[y, t] = impulse(sys, tFinal)\n[y, t] = impulse(sys, t)",
+            "output": "Response data is returned when outputs are requested; otherwise a plot is produced when plotting support is available."
+        },
+        "points": [
+            "`sys` must currently be a real, strictly proper SISO `tf` object.",
+            "`tFinal` must be a finite non-negative scalar.",
+            "`t` must be a real vector of finite non-negative strictly increasing times. For discrete systems, values must be integer multiples of `sys.Ts`."
+        ]
+    },
+    "validation": {
+        "summary": "`impulse` validates the model class, coefficient type and shape, delay properties, strict properness, sample time, and time vector before simulation. Tests cover SISO continuous response values, discrete response values, explicit time input, multi-output shapes, and representative diagnostics.",
+        "implementation": {
+            "label": "`crates/runmat-runtime/src/builtins/control/impulse.rs`",
+            "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/control/impulse.rs"
+        }
+    },
+    "gpu_residency": "`impulse` returns host-resident response vectors. It does not preserve gpuArray residency.",
+    "key": "impulse",
+    "slug": "impulse",
+    "aliases": [],
+    "categoryPath": [
+        "control"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=impulse.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"impulse.js","sourceRoot":"","sources":["../../../src/generated/builtins/impulse.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,SAAS;IACrB,UAAU,EAAE;QACV,SAAS;QACT,kBAAkB;QAClB,gBAAgB;QAChB,mBAAmB;QACnB,IAAI;KACL;IACD,SAAS,EAAE,0EAA0E;IACrF,YAAY,EAAE;QACZ,yCAAyC;QACzC,yDAAyD;KAC1D;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,mGAAmG;KAC7G;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;QACrB,OAAO,EAAE,6EAA6E;KACvF;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,mCAAmC;QAC3C,aAAa,EAAE,mCAAmC;KACnD;IACD,aAAa,EAAE,+PAA+P;IAC9Q,WAAW,EAAE;QACX,kFAAkF;QAClF,0DAA0D;QAC1D,qFAAqF;QACrF,qGAAqG;QACrG,mGAAmG;QACnG,gGAAgG;QAChG,gKAAgK;QAChK,4IAA4I;KAC7I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,8DAA8D;YACvE,QAAQ,EAAE,gCAAgC;SAC3C;QACD;YACE,aAAa,EAAE,0BAA0B;YACzC,OAAO,EAAE,kCAAkC;SAC5C;QACD;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,4DAA4D;SACtE;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,mIAAmI;SAC9I;QACD;YACE,UAAU,EAAE,0DAA0D;YACtE,QAAQ,EAAE,uIAAuI;SAClJ;QACD;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,kHAAkH;SAC7H;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,IAAI;YACb,KAAK,EAAE,MAAM;SACd;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,yDAAyD;QAClE,KAAK,EAAE,sGAAsG;KAC9G;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,iBAAiB;YAChC,OAAO,EAAE,gHAAgH;YACzH,QAAQ,EAAE,wHAAwH;SACnI;QACD,QAAQ,EAAE;YACR,mEAAmE;YACnE,gDAAgD;YAChD,iJAAiJ;SAClJ;KACF;IACD,YAAY,EAAE;QACZ,SAAS,EAAE,wSAAwS;QACnT,gBAAgB,EAAE;YAChB,OAAO,EAAE,yDAAyD;YAClE,KAAK,EAAE,sGAAsG;SAC9G;KACF;IACD,eAAe,EAAE,4FAA4F;IAC7G,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/integral.js

@@ -0,0 +1,101 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "integral",
+    "category": "math/optim",
+    "keywords": [
+        "integral",
+        "numerical integration",
+        "adaptive quadrature",
+        "quadrature",
+        "function handle"
+    ],
+    "summary": "Approximate a finite scalar definite integral using adaptive quadrature.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/integral.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "The adaptive solver runs on the host. Callback functions may still call GPU-aware builtins."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::optim::integral::tests",
+        "integration": "runmat-vm/tests/closures.rs::integral_accepts_anonymous_function"
+    },
+    "description": "`q = integral(fun, a, b)` approximates the definite integral of `fun` from `a` to `b`. The first implementation supports scalar-valued integrands over finite real bounds.",
+    "behaviors": [
+        "The function may be a named function handle such as `@sin`, an anonymous function such as `@(x) x.^2`, or a function-handle string.",
+        "The integration loop evaluates the integrand at scalar sample points and adapts subintervals using Simpson error estimates.",
+        "The integrand must return a finite real scalar. Array-valued and complex-valued integrands are not supported yet.",
+        "Finite reversed bounds are accepted and negate the result. Equal bounds return zero.",
+        "`AbsTol`, `RelTol`, and `MaxFunEvals` name/value options are accepted for the initial scalar implementation."
+    ],
+    "examples": [
+        {
+            "description": "Integrate a polynomial anonymous function",
+            "input": "q = integral(@(x) x.^2, 0, 1)",
+            "output": "q =\n    0.3333"
+        },
+        {
+            "description": "Integrate sine over one half-period",
+            "input": "q = integral(@sin, 0, pi)",
+            "output": "q =\n    2.0000"
+        },
+        {
+            "description": "Set tighter tolerances",
+            "input": "q = integral(@sin, 0, pi, 'AbsTol', 1e-12, 'RelTol', 1e-8)",
+            "output": "q =\n    2.0000"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Is this the same as trapz?",
+            "answer": "No. `integral` evaluates a function handle adaptively over continuous bounds. `trapz` integrates already-sampled discrete data."
+        },
+        {
+            "question": "Does integral support vector-valued functions?",
+            "answer": "Not yet. The initial implementation supports finite real scalar-valued integrands."
+        },
+        {
+            "question": "Does integral run on the GPU?",
+            "answer": "The adaptive solver runs on the host because it repeatedly invokes user code through function-handle dispatch. The callback itself may call GPU-aware builtins."
+        }
+    ],
+    "links": [
+        {
+            "label": "trapz",
+            "url": "./trapz"
+        },
+        {
+            "label": "cumtrapz",
+            "url": "./cumtrapz"
+        },
+        {
+            "label": "fzero",
+            "url": "./fzero"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/optim/integral.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/optim/integral.rs"
+    },
+    "key": "integral",
+    "slug": "integral",
+    "aliases": [],
+    "categoryPath": [
+        "math",
+        "optim"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=integral.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integral.js","sourceRoot":"","sources":["../../../src/generated/builtins/integral.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,uBAAuB;QACvB,qBAAqB;QACrB,YAAY;QACZ,iBAAiB;KAClB;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,6FAA6F;KACvG;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,kEAAkE;KAClF;IACD,aAAa,EAAE,4KAA4K;IAC3L,WAAW,EAAE;QACX,qIAAqI;QACrI,6HAA6H;QAC7H,mHAAmH;QACnH,sFAAsF;QACtF,8GAA8G;KAC/G;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,+BAA+B;YACxC,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,2BAA2B;YACpC,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,wBAAwB;YACvC,OAAO,EAAE,4DAA4D;YACrE,QAAQ,EAAE,iBAAiB;SAC5B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,4BAA4B;YACxC,QAAQ,EAAE,iIAAiI;SAC5I;QACD;YACE,UAAU,EAAE,gDAAgD;YAC5D,QAAQ,EAAE,oFAAoF;SAC/F;QACD;YACE,UAAU,EAAE,+BAA+B;YAC3C,QAAQ,EAAE,iKAAiK;SAC5K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;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/mode.d.ts

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

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

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