runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/polyder.js

@@ -0,0 +1,172 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "polyder",
+    "category": "math/poly",
+    "keywords": [
+        "polyder",
+        "polynomial derivative",
+        "product rule",
+        "quotient rule",
+        "gpu"
+    ],
+    "summary": "Differentiate polynomials, products, and ratios with MATLAB-compatible coefficient vectors.",
+    "references": [
+        "title: \"MATLAB polyder documentation\""
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "When the active provider implements the polyder hooks, differentiation runs entirely on the GPU; otherwise coefficients are gathered back to the host. Complex coefficients continue to fall back to the CPU."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::poly::polyder::tests",
+        "integration": "builtins::math::poly::polyder::tests::{gpu_inputs_remain_on_device,gpu_product_matches_cpu,gpu_quotient_matches_cpu,wgpu_polyder_single_matches_cpu,wgpu_polyder_product_matches_cpu,wgpu_polyder_quotient_matches_cpu}",
+        "vm": "ignition::vm polyder multi-output dispatch"
+    },
+    "description": "`polyder` differentiates polynomials represented by their coefficient vectors. The coefficients follow MATLAB’s convention: the first element corresponds to the highest power of `x`. The builtin supports three related operations:\n\n1. `polyder(p)` returns the derivative of a polynomial `p`. 2. `polyder(p, a)` applies the product rule to the convolution `conv(p, a)`. 3. `[num, den] = polyder(u, v)` returns the derivative of a rational function `u(x) / v(x)` using the quotient rule, yielding the numerator `num` and denominator `den`.",
+    "behaviors": [
+        "Accepts real or complex scalars, row vectors, column vectors, or empty vectors. Inputs with more than one non-singleton dimension raise MATLAB-compatible errors.",
+        "Logical and integer coefficients are promoted to double precision before differentiation.",
+        "Leading zeros are removed in outputs (unless the polynomial is identically zero, in which case a single zero coefficient is returned).",
+        "The orientation of the first input polynomial is preserved for the derivative of a single polynomial or a product; the denominator in the quotient rule preserves the orientation of `v`.",
+        "Calling `polyder(p, a)` with a single output applies the product rule. Capturing two outputs alongside two input polynomials returns the quotient-rule numerator and denominator (`u' * v - u * v'`, `v * v`).",
+        "Empty inputs are treated as the zero polynomial.",
+        "When inputs live on the GPU (e.g., `gpuArray`) and the active provider exposes the polyder hooks, differentiation runs entirely on-device and returns trimmed GPU tensors. Providers that lack the hooks fall back to gathering coefficients to the host, executing the reference CPU implementation, and returning host-resident results. Explicit calls to `gpuArray` remain available if you need to force residency."
+    ],
+    "examples": [
+        {
+            "description": "Differentiating a cubic polynomial",
+            "input": "p = [3 -2 5 7];   % 3x^3 - 2x^2 + 5x + 7\ndp = polyder(p)",
+            "output": "dp = [9 -4 5]"
+        },
+        {
+            "description": "Applying the product rule",
+            "input": "p = [1 0 -2];    % x^2 - 2\na = [1 1];       % x + 1\ndp = polyder(p, a);   % derivative of conv(p, a)",
+            "output": "dp = [3 2 -2]"
+        },
+        {
+            "description": "Differentiating a rational function",
+            "input": "u = [1 0 -4];      % x^2 - 4\nv = [1 -1];        % x - 1\n[num, den] = polyder(u, v);    % derivative of (u / v)",
+            "output": "num = [1 -2 4];\nden = [1 -2 1]"
+        },
+        {
+            "description": "Preserving column-vector orientation",
+            "input": "p = [1; 0; -3];    % column vector coefficients\ndp = polyder(p)",
+            "output": "dp =\n     2\n     0"
+        },
+        {
+            "description": "Differentiating complex-valued coefficients",
+            "input": "p = [1+2i, -3, 4i];\ndp = polyder(p)",
+            "output": "dp = [2+4i, -3]"
+        },
+        {
+            "description": "Working with gpuArray inputs",
+            "input": "g = gpuArray([2 0 -5 4]);\ndp = polyder(g);         % stays on the GPU when provider hooks are available\nresult = gather(dp)",
+            "output": "result = [6 0 -5]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What happens if I pass an empty coefficient vector?",
+            "answer": "The empty vector represents the zero polynomial. `polyder([])` returns `[0]`, and the product and quotient forms treat empty inputs as zeros."
+        },
+        {
+            "question": "Does `polyder` support column-vector coefficients?",
+            "answer": "Yes. The orientation of the first polynomial is preserved for single-polynomial and product derivatives. For the quotient rule, the numerator inherits the orientation of `u` and the denominator inherits the orientation of `v`."
+        },
+        {
+            "question": "How are leading zeros handled in the result?",
+            "answer": "Leading zeros are removed automatically to mirror MATLAB. If all coefficients cancel out, a single zero coefficient is returned."
+        },
+        {
+            "question": "Can I differentiate logical or integer coefficient vectors?",
+            "answer": "Yes. Logical and integer inputs are promoted to double precision before differentiation, matching MATLAB semantics."
+        },
+        {
+            "question": "How do I compute the derivative of a rational function?",
+            "answer": "Call `[num, den] = polyder(u, v)`. The numerator and denominator are the coefficients of `(u' * v - u * v')` and `v * v`, respectively, with leading zeros removed."
+        },
+        {
+            "question": "Does the builtin launch GPU kernels?",
+            "answer": "Yes whenever the active acceleration provider implements the `polyder` hooks. The in-process and WGPU backends both execute the derivative on the device. Providers that lack the hooks—or inputs that require complex arithmetic—fall back to the CPU reference implementation, returning the result on the host. Wrap the output in `gpuArray` manually if you need to restore device residency in that case."
+        },
+        {
+            "question": "What if I request more than two outputs?",
+            "answer": "`polyder` only defines one or two outputs. Additional requested outputs are filled with `0`, just as RunMat currently does for other MATLAB builtins whose extra outputs are ignored."
+        },
+        {
+            "question": "Are complex coefficients supported in the quotient rule?",
+            "answer": "Yes. Both the numerator and denominator are computed using full complex arithmetic, so mixed real/complex inputs work without additional steps."
+        },
+        {
+            "question": "Do I need to normalise or pad my coefficient vectors?",
+            "answer": "No. Provide coefficients exactly as MATLAB expects (highest power first). The builtin takes care of padding, trimming, and orientation."
+        },
+        {
+            "question": "How precise is the computation?",
+            "answer": "All arithmetic uses IEEE 754 double precision (`f64`), matching MATLAB’s default numeric type."
+        }
+    ],
+    "links": [
+        {
+            "label": "polyval",
+            "url": "./polyval"
+        },
+        {
+            "label": "polyfit",
+            "url": "./polyfit"
+        },
+        {
+            "label": "conv",
+            "url": "./conv"
+        },
+        {
+            "label": "deconv",
+            "url": "./deconv"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "polyint",
+            "url": "./polyint"
+        },
+        {
+            "label": "roots",
+            "url": "./roots"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/poly/polyder.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/poly/polyder.rs"
+    },
+    "gpu_behavior": [
+        "When a provider advertises the `polyder` hooks (the in-process and WGPU backends both do), single polynomials and the product/quotient forms execute fully on the GPU. Outputs preserve the orientation of the leading input while trimming leading zeros exactly as the CPU path does. If the provider declines the request—because the coefficients are complex or the backend lacks support— RunMat automatically gathers the inputs and falls back to the CPU reference implementation to preserve MATLAB compatibility."
+    ],
+    "key": "polyder",
+    "slug": "polyder",
+    "categoryPath": [
+        "math",
+        "poly"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=polyder.js.map

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

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

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

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

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

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

package/dist/generated/builtins/polyfit.js

@@ -0,0 +1,145 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "polyfit",
+    "category": "math/poly",
+    "keywords": [
+        "polyfit",
+        "polynomial fitting",
+        "least squares",
+        "prediction intervals",
+        "gpu"
+    ],
+    "summary": "Fit an n-th degree polynomial to data points using least squares with MATLAB-compatible outputs.",
+    "references": [
+        "title: \"MATLAB polyfit documentation\""
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Providers gather inputs to the host today; the shared Householder QR solver runs on CPU while preserving GPU residency semantics."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "uniform"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::poly::polyfit::tests",
+        "gpu": "builtins::math::poly::polyfit::tests::polyfit_wgpu_matches_cpu"
+    },
+    "description": "`polyfit(x, y, n)` returns the coefficients of an `n`-th degree polynomial that fits the samples `(x, y)` in a least-squares sense. The coefficients are ordered from the highest power of `x` (or `t` when centering is applied) down to the constant term, matching MATLAB's convention.",
+    "behaviors": [
+        "`x` and `y` must contain the same number of finite numeric elements. They can be row vectors, column vectors, or N-D arrays; RunMat flattens them column-major (MATLAB order).",
+        "The optional fourth argument provides weights: `polyfit(x, y, n, w)` minimises `||sqrt(w) .* (y - polyval(p, x))||_2`. All weights must be real, non-negative, and match the shape of `x`.",
+        "`polyfit` applies centring and scaling to the independent variable for numerical stability. It returns the vector `mu = [mean(x), std(x)]`, and the polynomial fits `(x - mu(1)) / mu(2)`. Use `polyval(p, x, [], mu)` to evaluate with the same scaling.",
+        "`[p, S, mu] = polyfit(...)` also returns `S`, a structure with fields `R`, `df`, and `normr`. These match MATLAB and are accepted directly by `polyval` for computing prediction intervals. `S.R` is the upper-triangular factor from the QR decomposition of the scaled Vandermonde matrix, `S.df` is the degrees of freedom (max(`numel(x) - (n + 1)`, 0)), and `S.normr` is the 2-norm of the weighted residuals.",
+        "RunMat mirrors MATLAB error messages for inconsistent dimensions, non-integer degrees, singular scaling, and invalid weights."
+    ],
+    "examples": [
+        {
+            "description": "Fitting a straight line through noisy samples",
+            "input": "x = 0:5;\ny = 2.5 * x + 1 + 0.05 * randn(size(x));\np = polyfit(x, y, 1)",
+            "output": "p ≈ [2.5 1.0];   % slope and intercept recovered from noisy data"
+        },
+        {
+            "description": "Computing a quadratic fit and reusing `mu`",
+            "input": "x = -3:3;\ny = x.^2 - 2 * x + 4;\n[p, S, mu] = polyfit(x, y, 2);\nsmoothed = polyval(p, x, [], mu)",
+            "output": "smoothed matches y exactly because the quadratic model fits perfectly."
+        },
+        {
+            "description": "Retrieving the structure `S` for prediction intervals",
+            "input": "t = linspace(0, 2*pi, 25);\ny = sin(t) + 0.1 * randn(size(t));\n[p, S, mu] = polyfit(t, y, 3);\n[fitted, delta] = polyval(p, t, S, mu)",
+            "output": "delta contains the one-standard-deviation prediction interval for each fitted sample."
+        },
+        {
+            "description": "Weighted polynomial fit",
+            "input": "x = linspace(-1, 1, 7);\ny = [1.1 0.4 0.2 0.0 0.1 0.5 1.4];\nw = [1 2 2 4 2 2 1];\np = polyfit(x, y, 2, w)",
+            "output": "Central samples influence the fit more heavily, matching MATLAB's weighting semantics."
+        },
+        {
+            "description": "Using `polyfit` with `gpuArray` inputs",
+            "input": "x = gpuArray.linspace(-2, 2, 50);\ny = gpuArray((x - 0.5).^3);\np = polyfit(x, y, 3)",
+            "output": "p is returned on the host today; convert it back to gpuArray if desired."
+        },
+        {
+            "description": "Complex-valued data with `polyfit`",
+            "input": "x = 0:4;\ny = exp(1i * x);\np = polyfit(x, y, 2)",
+            "output": "p is complex-valued and matches MATLAB's complex least-squares solution."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What degree polynomial should I choose?",
+            "answer": "You must specify the degree `n` explicitly. A degree of `numel(x) - 1` interpolates the data exactly, but higher degrees amplify noise dramatically. Use validation, cross-validation, or domain knowledge to select a sensible degree."
+        },
+        {
+            "question": "What do the outputs `S` and `mu` represent?",
+            "answer": "`S` packages the QR factors (`R`), degrees of freedom (`df`), and residual norm (`normr`) so you can call `polyval(p, x, S, mu)` to obtain prediction intervals. `mu = [mean(x), std(x)]` records the centering and scaling applied during the fit."
+        },
+        {
+            "question": "How are weights interpreted?",
+            "answer": "Weights act multiplicatively on the residual norm. RunMat minimises `||sqrt(w) .* (y - polyval(p, x))||_2`. Zero weights ignore corresponding samples; negative weights are not allowed and trigger MATLAB-style errors."
+        },
+        {
+            "question": "Can I keep the outputs on the GPU?",
+            "answer": "Today the solver runs on the CPU even when inputs live on the GPU. The returned coefficients, `S`, and `mu` are CPU values. You can convert them back to `gpuArray` manually if needed. Future provider updates may keep everything on the device automatically."
+        },
+        {
+            "question": "Why does `mu(2)` need to be non-zero?",
+            "answer": "`mu(2)` is the scaling factor (standard deviation) applied to `x`. If all `x` values are identical, the polynomial is ill-conditioned. RunMat mirrors MATLAB by treating this as a singular scaling and raising an error unless the degree is zero."
+        }
+    ],
+    "links": [
+        {
+            "label": "polyval",
+            "url": "./polyval"
+        },
+        {
+            "label": "roots",
+            "url": "./roots"
+        },
+        {
+            "label": "mldivide",
+            "url": "./mldivide"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "polyder",
+            "url": "./polyder"
+        },
+        {
+            "label": "polyint",
+            "url": "./polyint"
+        }
+    ],
+    "source": {
+        "label": "Open a RunMat issue",
+        "url": "https://github.com/runmat-org/runmat/issues/new/choose"
+    },
+    "gpu_behavior": [
+        "RunMat’s acceleration layer exposes a dedicated `polyfit` provider hook. The WGPU provider routes requests through this hook, gathers inputs to the host, executes the shared Householder QR solver, and returns MATLAB-compatible outputs while preserving residency metadata. Providers that have not implemented the hook yet fall back to the same host code path automatically, so results stay correct even when the inputs originated on the GPU."
+    ],
+    "key": "polyfit",
+    "slug": "polyfit",
+    "categoryPath": [
+        "math",
+        "poly"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=polyfit.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"polyfit.js","sourceRoot":"","sources":["../../../src/generated/builtins/polyfit.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,WAAW;IACvB,UAAU,EAAE;QACV,SAAS;QACT,oBAAoB;QACpB,eAAe;QACf,sBAAsB;QACtB,KAAK;KACN;IACD,SAAS,EAAE,kGAAkG;IAC7G,YAAY,EAAE;QACZ,yCAAyC;KAC1C;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,mIAAmI;KAC7I;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,SAAS;KACvB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,sCAAsC;QAC9C,KAAK,EAAE,gEAAgE;KACxE;IACD,aAAa,EAAE,4RAA4R;IAC3S,WAAW,EAAE;QACX,gLAAgL;QAChL,4LAA4L;QAC5L,2PAA2P;QAC3P,sZAAsZ;QACtZ,+HAA+H;KAChI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,0EAA0E;YACnF,QAAQ,EAAE,kEAAkE;SAC7E;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,oGAAoG;YAC7G,QAAQ,EAAE,wEAAwE;SACnF;QACD;YACE,aAAa,EAAE,uDAAuD;YACtE,OAAO,EAAE,wIAAwI;YACjJ,QAAQ,EAAE,uFAAuF;SAClG;QACD;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,4GAA4G;YACrH,QAAQ,EAAE,wFAAwF;SACnG;QACD;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,sFAAsF;YAC/F,QAAQ,EAAE,0EAA0E;SACrF;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,kDAAkD;YAC3D,QAAQ,EAAE,0EAA0E;SACrF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,yOAAyO;SACpP;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,qPAAqP;SAChQ;QACD;YACE,UAAU,EAAE,8BAA8B;YAC1C,QAAQ,EAAE,0NAA0N;SACrO;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,kQAAkQ;SAC7Q;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,qPAAqP;SAChQ;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,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,qBAAqB;QAC9B,KAAK,EAAE,wDAAwD;KAChE;IACD,cAAc,EAAE;QACd,0bAA0b;KAC3b;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,cAAc,EAAE;QACd,MAAM;QACN,MAAM;KACP;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/polyint.js

@@ -0,0 +1,148 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "polyint",
+    "category": "math/poly",
+    "keywords": [
+        "polyint",
+        "polynomial integral",
+        "antiderivative",
+        "integration constant",
+        "gpu"
+    ],
+    "summary": "Integrate polynomial coefficient vectors and append a constant of integration.",
+    "references": [
+        "title: \"MATLAB polyint documentation\""
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Real-valued coefficient vectors stay on the GPU when the provider exposes the polyint hook; complex outputs fall back to the host."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::poly::polyint::tests",
+        "integration": "builtins::math::poly::polyint::tests::polyint_gpu_roundtrip"
+    },
+    "description": "`polyint(p)` returns the polynomial that integrates the coefficient vector `p` once, appending the constant of integration at the end of the coefficient list. Coefficients follow MATLAB's descending power convention: `p(1)` multiplies the highest power of `x`, and `p(end)` is the constant term.",
+    "behaviors": [
+        "Accepts real or complex scalars, row vectors, column vectors, or empty vectors. Inputs with more than one non-singleton dimension raise MATLAB-compatible errors.",
+        "Logical and integer coefficients are promoted to double precision before integration.",
+        "The optional second argument supplies the constant of integration. It must be a scalar (real or complex). When omitted, the constant defaults to `0`.",
+        "Leading zeros are preserved. Integrating `[0 0 5]` produces `[0 0 5 0]`, matching MATLAB.",
+        "Empty inputs integrate to the constant of integration (default `0`). Specifying a constant `k` yields `[k]`.",
+        "The orientation of the input vector is preserved: row vectors stay row vectors, column vectors stay column vectors, and scalars return a row vector.",
+        "When coefficients reside on the GPU, RunMat gathers them to the host, performs the integration, and re-uploads real-valued results so downstream kernels retain residency."
+    ],
+    "examples": [
+        {
+            "description": "Integrating a cubic polynomial",
+            "input": "p = [3 -2 5 7];        % 3x^3 - 2x^2 + 5x + 7\nq = polyint(p)",
+            "output": "q = [0.75  -0.6667  2.5  7  0]"
+        },
+        {
+            "description": "Supplying a constant of integration",
+            "input": "p = [4 0 -8];\nq = polyint(p, 3)",
+            "output": "q = [1.3333  0  -8  3]"
+        },
+        {
+            "description": "Preserving column-vector orientation",
+            "input": "p = [2; 0; -6];\nq = polyint(p)",
+            "output": "q =\n    0.6667\n         0\n   -6.0000\n         0"
+        },
+        {
+            "description": "Integrating the zero polynomial",
+            "input": "q = polyint([])",
+            "output": "q = 0"
+        },
+        {
+            "description": "Integrating complex coefficients",
+            "input": "p = [1+2i  -3  4i];\nq = polyint(p, -1i)",
+            "output": "q = [(1+2i)/3  -1.5  4i  -1i]"
+        },
+        {
+            "description": "Working with gpuArray inputs",
+            "input": "g = gpuArray([1 -4 6]);\nq = polyint(g);          % Gathered to host, integrated, and re-uploaded\nresult = gather(q)",
+            "output": "result = [0.3333  -2  6  0]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `polyint` change the orientation of my coefficients?",
+            "answer": "No. Row vectors stay row vectors, column vectors stay column vectors, and scalars return a row vector with two elements after integration."
+        },
+        {
+            "question": "What happens when I pass an empty vector?",
+            "answer": "An empty vector represents the zero polynomial. `polyint([])` returns the constant of integration, so the default result is `0` and `polyint([], k)` returns `k`."
+        },
+        {
+            "question": "Can the constant of integration be complex?",
+            "answer": "Yes. Provide any scalar numeric value (real or complex). The constant is appended to the integrated polynomial exactly as MATLAB does."
+        },
+        {
+            "question": "Are logical or integer coefficients supported?",
+            "answer": "Yes. They are promoted to double precision before integration, ensuring identical behaviour to MATLAB."
+        },
+        {
+            "question": "Will the result stay on the GPU?",
+            "answer": "Real-valued outputs are re-uploaded to the GPU when a provider is available. Complex outputs remain on the host because current providers do not expose complex tensor handles."
+        },
+        {
+            "question": "How precise is the computation?",
+            "answer": "All arithmetic uses IEEE 754 double precision (`f64`), mirroring MATLAB's default numeric type."
+        }
+    ],
+    "links": [
+        {
+            "label": "polyder",
+            "url": "./polyder"
+        },
+        {
+            "label": "polyval",
+            "url": "./polyval"
+        },
+        {
+            "label": "polyfit",
+            "url": "./polyfit"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "roots",
+            "url": "./roots"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/poly/polyint.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/poly/polyint.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` just for `polyint`. When inputs already live on the GPU and a provider is active, RunMat keeps the data on the device and executes the integration there for real-valued coefficients. For complex inputs, or when no provider hook is available, the runtime falls back to the host implementation transparently.",
+    "gpu_behavior": [
+        "When a GPU provider is registered and the coefficient vector is real-valued, RunMat calls the provider's dedicated `polyint` kernel. The input stays on the device, the kernel divides each coefficient by the appropriate power, and the supplied constant of integration is written directly into device memory. If the coefficients or the constant are complex, or if the provider reports that the hook is unavailable, the runtime gathers data back to the host, performs the integration in double precision, and re-uploads the result when it is purely real."
+    ],
+    "key": "polyint",
+    "slug": "polyint",
+    "categoryPath": [
+        "math",
+        "poly"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=polyint.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"polyint.js","sourceRoot":"","sources":["../../../src/generated/builtins/polyint.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,WAAW;IACvB,UAAU,EAAE;QACV,SAAS;QACT,qBAAqB;QACrB,gBAAgB;QAChB,sBAAsB;QACtB,KAAK;KACN;IACD,SAAS,EAAE,gFAAgF;IAC3F,YAAY,EAAE;QACZ,yCAAyC;KAC1C;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,oIAAoI;KAC9I;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,sCAAsC;QAC9C,aAAa,EAAE,6DAA6D;KAC7E;IACD,aAAa,EAAE,ySAAyS;IACxT,WAAW,EAAE;QACX,mKAAmK;QACnK,uFAAuF;QACvF,uJAAuJ;QACvJ,2FAA2F;QAC3F,8GAA8G;QAC9G,sJAAsJ;QACtJ,4KAA4K;KAC7K;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,+DAA+D;YACxE,QAAQ,EAAE,gCAAgC;SAC3C;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,kCAAkC;YAC3C,QAAQ,EAAE,wBAAwB;SACnC;QACD;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,iCAAiC;YAC1C,QAAQ,EAAE,qDAAqD;SAChE;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,iBAAiB;YAC1B,QAAQ,EAAE,OAAO;SAClB;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,0CAA0C;YACnD,QAAQ,EAAE,+BAA+B;SAC1C;QACD;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,uHAAuH;YAChI,QAAQ,EAAE,6BAA6B;SACxC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2DAA2D;YACvE,QAAQ,EAAE,4IAA4I;SACvJ;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,mKAAmK;SAC9K;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,wIAAwI;SACnJ;QACD;YACE,UAAU,EAAE,gDAAgD;YAC5D,QAAQ,EAAE,wGAAwG;SACnH;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,iLAAiL;SAC5L;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,iGAAiG;SAC5G;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,eAAe,EAAE,mWAAmW;IACpX,cAAc,EAAE;QACd,yiBAAyiB;KAC1iB;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,cAAc,EAAE;QACd,MAAM;QACN,MAAM;KACP;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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