runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/roots.js

@@ -0,0 +1,135 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "roots",
+    "category": "math/poly",
+    "keywords": [
+        "roots",
+        "polynomial roots",
+        "companion matrix",
+        "eigenvalues",
+        "gpu"
+    ],
+    "summary": "Compute the roots of a polynomial specified by its coefficients, matching MATLAB semantics including complex output.",
+    "references": [
+        "title: \"MATLAB roots documentation\"",
+        "title: \"Golub & Van Loan – Matrix Computations, Chapter 7\""
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Roots builds a companion matrix and computes its eigenvalues on the CPU; GPU inputs are gathered automatically."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::poly::roots::tests",
+        "integration": "builtins::math::poly::roots::tests::roots_gpu_input_gathers_to_host"
+    },
+    "description": "`roots(p)` returns the zeros of the polynomial whose coefficients are stored in `p`, with coefficients ordered from the highest power of `x` to the constant term. The result is always a column vector whose entries may be complex.",
+    "behaviors": [
+        "Leading zeros in the coefficient vector are discarded before solving. If all coefficients are zero, the result is an empty column vector.",
+        "Constant polynomials (degree 0) produce an empty output because they have no finite roots.",
+        "Linear polynomials return the single solution `-b/a`. Higher-degree polynomials are solved via the eigenvalues of the companion matrix.",
+        "Real coefficients can generate complex conjugate root pairs. Small imaginary round-off terms are rounded to zero to match MATLAB formatting.",
+        "Input vectors can be row or column vectors. Higher-dimensional arrays are rejected.",
+        "Inputs may be real or complex. Logical and integer types are converted to double precision automatically."
+    ],
+    "examples": [
+        {
+            "description": "Finding roots of a quadratic polynomial",
+            "input": "p = [1 -3 2];\nr = roots(p)",
+            "output": "r =\n     2\n     1"
+        },
+        {
+            "description": "Computing roots that include repeated factors",
+            "input": "p = [1 -2 1 0];   % (x - 1)^2 * x\nr = roots(p)",
+            "output": "r =\n     1\n     1\n     0"
+        },
+        {
+            "description": "Handling leading zeros in the coefficient vector",
+            "input": "p = [0 0 1 -4];\nr = roots(p)",
+            "output": "r =\n     4"
+        },
+        {
+            "description": "Calculating complex roots from real coefficients",
+            "input": "p = [1 0 1];\nr = roots(p)",
+            "output": "r =\n   0.0000 + 1.0000i\n   0.0000 - 1.0000i"
+        },
+        {
+            "description": "Solving roots of a polynomial stored on the GPU",
+            "input": "p = gpuArray([1 0 -9 0]);\nr = roots(p)",
+            "output": "r =\n    3.0000\n   -3.0000\n         0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What shape must the coefficient vector have?",
+            "answer": "`roots` accepts row vectors, column vectors, or 1-D arrays. Higher-dimensional tensors are rejected with an error."
+        },
+        {
+            "question": "How are leading zeros handled?",
+            "answer": "Leading zeros are removed before solving. If all coefficients are zero, `roots` returns an empty column vector."
+        },
+        {
+            "question": "Does `roots` preserve the data type of the coefficients?",
+            "answer": "Coefficients are promoted to double precision internally. The output is a double vector when all roots are real and a complex double vector otherwise."
+        },
+        {
+            "question": "Are the roots sorted?",
+            "answer": "Roots are returned in the order supplied by the eigenvalue computation (typically descending magnitude). MATLAB also does not sort the roots."
+        },
+        {
+            "question": "Can I run `roots` entirely on the GPU?",
+            "answer": "Not yet. RunMat gathers coefficients from the GPU, solves the companion matrix on the CPU, and returns a host-resident vector. When GPU providers add a polynomial root solver, this builtin will automatically route to it."
+        },
+        {
+            "question": "How does RunMat handle numerical round-off?",
+            "answer": "Small imaginary components (|imag| ≤ 1e-10·(1 + |real|)) are rounded to zero so that near-real roots are displayed as real numbers, matching MATLAB formatting."
+        }
+    ],
+    "links": [
+        {
+            "label": "polyval",
+            "url": "./polyval"
+        },
+        {
+            "label": "polyfit",
+            "url": "./polyfit"
+        },
+        {
+            "label": "roots",
+            "url": "./roots"
+        },
+        {
+            "label": "polyder",
+            "url": "./polyder"
+        },
+        {
+            "label": "polyint",
+            "url": "./polyint"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/poly/roots.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/poly/roots.rs"
+    },
+    "gpu_behavior": [
+        "RunMat gathers GPU-resident coefficient vectors to the host because the companion matrix eigenvalue computation presently runs only on the CPU. The output is produced on the host as well. When future providers supply a dedicated polynomial root solver, the builtin can be updated to keep residency on-device transparently."
+    ],
+    "key": "roots",
+    "slug": "roots",
+    "categoryPath": [
+        "math",
+        "poly"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=roots.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"roots.js","sourceRoot":"","sources":["../../../src/generated/builtins/roots.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,WAAW;IACvB,UAAU,EAAE;QACV,OAAO;QACP,kBAAkB;QAClB,kBAAkB;QAClB,aAAa;QACb,KAAK;KACN;IACD,SAAS,EAAE,sHAAsH;IACjI,YAAY,EAAE;QACZ,uCAAuC;QACvC,8DAA8D;KAC/D;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,iHAAiH;KAC3H;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,oCAAoC;QAC5C,aAAa,EAAE,qEAAqE;KACrF;IACD,aAAa,EAAE,uOAAuO;IACtP,WAAW,EAAE;QACX,2IAA2I;QAC3I,4FAA4F;QAC5F,yIAAyI;QACzI,8IAA8I;QAC9I,qFAAqF;QACrF,2GAA2G;KAC5G;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,6BAA6B;YACtC,QAAQ,EAAE,qBAAqB;SAChC;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,iDAAiD;YAC1D,QAAQ,EAAE,6BAA6B;SACxC;QACD;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,+BAA+B;YACxC,QAAQ,EAAE,aAAa;SACxB;QACD;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,+CAA+C;SAC1D;QACD;YACE,aAAa,EAAE,iDAAiD;YAChE,OAAO,EAAE,yCAAyC;YAClD,QAAQ,EAAE,yCAAyC;SACpD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,8CAA8C;YAC1D,QAAQ,EAAE,oHAAoH;SAC/H;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,iHAAiH;SAC5H;QACD;YACE,UAAU,EAAE,0DAA0D;YACtE,QAAQ,EAAE,wJAAwJ;SACnK;QACD;YACE,UAAU,EAAE,uBAAuB;YACnC,QAAQ,EAAE,+IAA+I;SAC1J;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,8NAA8N;SACzO;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,iKAAiK;SAC5K;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,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;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,yDAAyD;QAClE,KAAK,EAAE,sGAAsG;KAC9G;IACD,cAAc,EAAE;QACd,oUAAoU;KACrU;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,cAAc,EAAE;QACd,MAAM;QACN,MAAM;KACP;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/rot90.js

@@ -0,0 +1,200 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "rot90",
+    "category": "array/shape",
+    "keywords": [
+        "rot90",
+        "rotate",
+        "90 degrees",
+        "matrix",
+        "gpu",
+        "clockwise",
+        "counterclockwise"
+    ],
+    "summary": "Rotate matrices and N-D arrays by multiples of 90 degrees.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Uses provider permute + flip hooks when available; otherwise gathers once, rotates on the host, and re-uploads."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::shape::rot90::tests",
+        "integration": "builtins::array::shape::rot90::tests::rot90_gpu_roundtrip"
+    },
+    "description": "`rot90(A)` rotates the matrix `A` by 90 degrees counterclockwise. A second argument specifies additional 90-degree turns (positive values rotate counterclockwise, negative values clockwise). For N-D arrays, only the first two dimensions participate in the rotation; trailing dimensions remain unchanged.",
+    "behaviors": [
+        "Default behaviour rotates 90 degrees counterclockwise (`k = 1`).",
+        "`rot90(A, K)` rotates by `K * 90°`; the rotation count can be positive, negative, or zero. Any integer multiple of four leaves the input unchanged.",
+        "The direction keywords `'clockwise'` and `'counterclockwise'` are accepted as an alternative to the numeric argument (case-insensitive).",
+        "Works for numeric tensors, logical masks, complex arrays, string arrays, and character matrices. Scalars are unchanged.",
+        "For empty dimensions the function still swaps the first two extents, so `rot90(zeros(0, 3))` returns a `3×0` array."
+    ],
+    "examples": [
+        {
+            "description": "Rotating a matrix 90 degrees counterclockwise",
+            "input": "A = [1 2 3; 4 5 6];\nB = rot90(A)",
+            "output": "B =\n     3     6\n     2     5\n     1     4"
+        },
+        {
+            "description": "Rotating a matrix clockwise using a direction keyword",
+            "input": "A = magic(3);\nC = rot90(A, 'clockwise')",
+            "output": "C =\n     6     1     8\n     7     5     3\n     2     9     4"
+        },
+        {
+            "description": "Applying multiple 90-degree turns with a numeric count",
+            "input": "A = reshape(1:9, [3 3]);\nB = rot90(A, 2);    % 180-degree rotation",
+            "output": "B =\n     9     8     7\n     6     5     4\n     3     2     1"
+        },
+        {
+            "description": "Rotating 3-D data while preserving trailing dimensions",
+            "input": "T = reshape(1:12, [2 3 2]);\nR = rot90(T);\nsize(R)",
+            "output": "ans =\n     3     2     2"
+        },
+        {
+            "description": "Rotating character data to reorganise text",
+            "input": "C = ['r','u','n'; 'm','a','t'; ' ','A','I'];\nR = rot90(C)",
+            "output": "R =\n    'ntI'\n    'uaA'\n    'rm '"
+        },
+        {
+            "description": "Rotating gpuArray data and keeping it on the device",
+            "input": "G = gpuArray(reshape(1:9, [3 3]));\nH = rot90(G, -1);     % rotate clockwise\nisgpuarray(H)",
+            "output": "ans = logical 1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What directions does `rot90` support?",
+            "answer": "Numeric rotation counts (integers) and the strings `'clockwise'` / `'counterclockwise'` are recognised. Any other strings raise an error."
+        },
+        {
+            "question": "Does `rot90` modify dimensions beyond the first two?",
+            "answer": "No. Only the first two axes participate in the rotation. Other dimensions keep their order and extents unchanged."
+        },
+        {
+            "question": "What happens for empty matrices?",
+            "answer": "Empty inputs still swap the first two dimension sizes. For example, a `0×5` matrix becomes `5×0` after a single counterclockwise rotation."
+        },
+        {
+            "question": "Can I rotate logical, string, or character arrays?",
+            "answer": "Yes. Logical results remain logical, string arrays preserve their elements, and character matrices rotate their characters exactly like numeric data."
+        },
+        {
+            "question": "How do large rotation counts behave?",
+            "answer": "The rotation count is reduced modulo 4. Values such as `rot90(A, 37)` behave the same as `rot90(A, 1)`."
+        },
+        {
+            "question": "Is `rot90` compatible with complex numbers?",
+            "answer": "Absolutely. Complex tensors rotate without altering the real or imaginary parts; only the element positions change."
+        },
+        {
+            "question": "Can providers implement a custom kernel?",
+            "answer": "Yes. Providers may implement a specialised `rot90` kernel. When unavailable, the runtime composes the operation using the `permute` and `flip` hooks or falls back to the host implementation."
+        }
+    ],
+    "links": [
+        {
+            "label": "`flip`",
+            "url": "./flip"
+        },
+        {
+            "label": "`permute`",
+            "url": "./permute"
+        },
+        {
+            "label": "`reshape`",
+            "url": "./reshape"
+        },
+        {
+            "label": "`kron`",
+            "url": "./kron"
+        },
+        {
+            "label": "`gpuArray`",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "`gather`",
+            "url": "./gather"
+        },
+        {
+            "label": "cat",
+            "url": "./cat"
+        },
+        {
+            "label": "circshift",
+            "url": "./circshift"
+        },
+        {
+            "label": "diag",
+            "url": "./diag"
+        },
+        {
+            "label": "fliplr",
+            "url": "./fliplr"
+        },
+        {
+            "label": "flipud",
+            "url": "./flipud"
+        },
+        {
+            "label": "horzcat",
+            "url": "./horzcat"
+        },
+        {
+            "label": "ipermute",
+            "url": "./ipermute"
+        },
+        {
+            "label": "repmat",
+            "url": "./repmat"
+        },
+        {
+            "label": "squeeze",
+            "url": "./squeeze"
+        },
+        {
+            "label": "tril",
+            "url": "./tril"
+        },
+        {
+            "label": "triu",
+            "url": "./triu"
+        },
+        {
+            "label": "vertcat",
+            "url": "./vertcat"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/shape/rot90.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/shape/rot90.rs"
+    },
+    "gpu_residency": "Not usually. The auto-offload planner keeps tensors on the GPU whenever it is profitable. Explicitly creating a `gpuArray` matches MATLAB syntax, but RunMat will also auto-promote host tensors when the planner determines that rotating them on the device avoids unnecessary transfers. When the active provider lacks native support the runtime downloads the tensor once, rotates on the host, and uploads the rotated tensor back to the GPU so downstream operations continue to benefit from residency information.",
+    "gpu_behavior": [
+        "Providers that implement both `permute` and `flip` can realise the rotation without leaving the GPU, preserving residency for downstream operations.",
+        "If a dedicated `rot90` kernel is exposed the provider may call it instead of composing lower-level hooks.",
+        "When no compatible hooks are available, RunMat gathers the tensor once, rotates it on the host, and re-uploads the rotated tensor so subsequent GPU work continues without surprises."
+    ],
+    "key": "rot90",
+    "slug": "rot90",
+    "categoryPath": [
+        "array",
+        "shape"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=rot90.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rot90.js","sourceRoot":"","sources":["../../../src/generated/builtins/rot90.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,OAAO;QACP,QAAQ;QACR,YAAY;QACZ,QAAQ;QACR,KAAK;QACL,WAAW;QACX,kBAAkB;KACnB;IACD,SAAS,EAAE,4DAA4D;IACvE,YAAY,EAAE,EAAE;IAChB,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,iHAAiH;KAC3H;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,2DAA2D;KAC3E;IACD,aAAa,EAAE,iTAAiT;IAChU,WAAW,EAAE;QACX,kEAAkE;QAClE,qJAAqJ;QACrJ,0IAA0I;QAC1I,yHAAyH;QACzH,qHAAqH;KACtH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,mCAAmC;YAC5C,QAAQ,EAAE,+CAA+C;SAC1D;QACD;YACE,aAAa,EAAE,uDAAuD;YACtE,OAAO,EAAE,0CAA0C;YACnD,QAAQ,EAAE,iEAAiE;SAC5E;QACD;YACE,aAAa,EAAE,wDAAwD;YACvE,OAAO,EAAE,qEAAqE;YAC9E,QAAQ,EAAE,iEAAiE;SAC5E;QACD;YACE,aAAa,EAAE,wDAAwD;YACvE,OAAO,EAAE,qDAAqD;YAC9D,QAAQ,EAAE,2BAA2B;SACtC;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,4DAA4D;YACrE,QAAQ,EAAE,sCAAsC;SACjD;QACD;YACE,aAAa,EAAE,qDAAqD;YACpE,OAAO,EAAE,6FAA6F;YACtG,QAAQ,EAAE,iBAAiB;SAC5B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,2IAA2I;SACtJ;QACD;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,mHAAmH;SAC9H;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,4IAA4I;SACvJ;QACD;YACE,UAAU,EAAE,oDAAoD;YAChE,QAAQ,EAAE,uJAAuJ;SAClK;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,yGAAyG;SACpH;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,qHAAqH;SAChI;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,gMAAgM;SAC3M;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;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,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,eAAe,EAAE,+fAA+f;IAChhB,cAAc,EAAE;QACd,sJAAsJ;QACtJ,2GAA2G;QAC3G,uLAAuL;KACxL;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,cAAc,EAAE;QACd,OAAO;QACP,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/round.js

@@ -0,0 +1,161 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "round",
+    "category": "math/rounding",
+    "keywords": [
+        "round",
+        "rounding",
+        "significant digits",
+        "decimals",
+        "gpu"
+    ],
+    "summary": "Round scalars, vectors, matrices, or N-D tensors to the nearest integers, decimal digits, or significant digits.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Falls back to the host implementation when rounding to digits or significant figures if the active provider lacks unary_round."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::rounding::round::tests",
+        "integration": "builtins::math::rounding::round::tests::round_gpu_provider_roundtrip"
+    },
+    "description": "`round(X)` rounds numeric values to the nearest integers using MATLAB-compatible half-away-from-zero semantics. Additional arguments allow rounding to a specified number of decimal digits or significant digits.",
+    "behaviors": [
+        "`round(X)` rounds each element of `X` to the nearest integer; ties (e.g., `±0.5`) round away from zero.",
+        "`round(X, N)` rounds to `N` decimal digits when `N` is positive and to powers of ten when `N` is negative.",
+        "`round(X, N, 'significant')` rounds to `N` significant digits. `N` must be a positive integer.",
+        "Logical inputs are promoted to double before rounding; `round(true)` returns `1`.",
+        "Complex inputs are rounded component-wise (`round(a + bi) = round(a) + i·round(b)`), matching MATLAB.",
+        "Non-finite values (`NaN`, `Inf`, `-Inf`) propagate unchanged regardless of precision arguments.",
+        "Character arrays are treated as their numeric code points and return double tensors of the same size."
+    ],
+    "examples": [
+        {
+            "description": "Rounding values to the nearest integers",
+            "input": "X = [-3.5 -2.2 -0.5 0 0.5 1.7];\nY = round(X)",
+            "output": "Y = [-4 -2 -1 0 1 2]"
+        },
+        {
+            "description": "Rounding to a fixed number of decimal places",
+            "input": "temps = [21.456 19.995 22.501];\nrounded = round(temps, 2)",
+            "output": "rounded = [21.46 20.00 22.50]"
+        },
+        {
+            "description": "Rounding to negative powers of ten",
+            "input": "counts = [1234 5678 91011];\nrounded = round(counts, -2)",
+            "output": "rounded = [1200 5700 91000]"
+        },
+        {
+            "description": "Rounding to significant digits",
+            "input": "measurements = [0.001234 12.3456 98765];\nsig3 = round(measurements, 3, 'significant')",
+            "output": "sig3 = [0.00123 12.3 98800]"
+        },
+        {
+            "description": "Rounding GPU tensors and gathering the results",
+            "input": "G = gpuArray(linspace(-2.5, 2.5, 6));\nrounded = round(G);\nhostValues = gather(rounded)",
+            "output": "hostValues = [-3 -2 -1 1 2 3]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `round` always round half values away from zero?",
+            "answer": "Yes. MATLAB and RunMat both use half-away-from-zero semantics, so `round(0.5)` returns `1` and `round(-0.5)` returns `-1`."
+        },
+        {
+            "question": "Can I round to decimal places and significant digits?",
+            "answer": "Yes. Use `round(X, N)` for decimal places and `round(X, N, 'significant')` for significant digits. Negative `N` values round to tens, hundreds, and so on."
+        },
+        {
+            "question": "What happens if I pass a non-integer `N`?",
+            "answer": "`N` must be an integer scalar. RunMat raises a MATLAB-compatible error when `N` is not an integer or is non-finite."
+        },
+        {
+            "question": "How are complex numbers handled?",
+            "answer": "RunMat rounds the real and imaginary components independently, matching MATLAB's component-wise behaviour."
+        },
+        {
+            "question": "Do NaN or Inf values change when rounded?",
+            "answer": "No. Non-finite values propagate unchanged for every rounding mode, just like MATLAB."
+        },
+        {
+            "question": "Will rounding stay on the GPU?",
+            "answer": "`round(X)` stays on the GPU when the provider implements `unary_round`. Rounding with digit arguments currently gathers to the host; providers can override this by adding specialised kernels."
+        },
+        {
+            "question": "Can I round logical or character arrays?",
+            "answer": "Yes. Logical values are converted to doubles (`0` or `1`) and characters are rounded as their numeric code points, returning dense double tensors."
+        },
+        {
+            "question": "What does round do in MATLAB?",
+            "answer": "`round(X)` rounds each element of `X` to the nearest integer. `round(X, N)` rounds to `N` decimal places. Ties (e.g., 2.5) round away from zero."
+        },
+        {
+            "question": "What is the difference between round, floor, and ceil in MATLAB?",
+            "answer": "`round` rounds to the nearest integer, `floor` rounds toward negative infinity, and `ceil` rounds toward positive infinity. For 2.5: `round` returns 3, `floor` returns 2, `ceil` returns 3."
+        },
+        {
+            "question": "Does round support GPU acceleration in RunMat?",
+            "answer": "Yes. `round` runs on the GPU with elementwise fusion support. It accepts `f32` and `f64` precisions and supports MATLAB-compatible broadcasting."
+        }
+    ],
+    "links": [
+        {
+            "label": "floor",
+            "url": "./floor"
+        },
+        {
+            "label": "ceil",
+            "url": "./ceil"
+        },
+        {
+            "label": "fix",
+            "url": "./fix"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "mod",
+            "url": "./mod"
+        },
+        {
+            "label": "rem",
+            "url": "./rem"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/rounding/round.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/rounding/round.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` manually. RunMat's planner keeps tensors on the GPU when the provider exposes the required kernels and it is profitable to do so. `round` takes advantage of this mechanism for the plain `round(X)` form. When you specify digits or the `'significant'` option, RunMat currently gathers data to the host to match MATLAB exactly. Future providers can extend `unary_round` or add digit-aware kernels to keep those workloads on the device.",
+    "gpu_behavior": [
+        "When a tensor already resides on the GPU, RunMat checks whether the active acceleration provider implements a specialised `unary_round` kernel. If available, `round(X)` executes entirely on the device. Advanced modes (`round(X, N)` and `round(X, N, 'significant')`) currently gather tensors to the host before rounding to keep semantics aligned with MATLAB. Providers that add digit-aware kernels can extend this path in the future."
+    ],
+    "key": "round",
+    "slug": "round",
+    "categoryPath": [
+        "math",
+        "rounding"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=round.js.map

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

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

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

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

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

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