runmat 0.3.5 → 0.4.0

package/dist/generated/builtins/expm1.js

@@ -0,0 +1,227 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "expm1",
+    "category": "math/elementwise",
+    "keywords": [
+        "expm1",
+        "exp(x)-1",
+        "exponential",
+        "elementwise",
+        "gpu",
+        "precision"
+    ],
+    "summary": "Accurate element-wise computation of exp(x) - 1 for scalars, vectors, matrices, or N-D tensors.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Falls back to the host implementation when the active provider lacks unary_expm1."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::elementwise::expm1::tests",
+        "integration": "builtins::math::elementwise::expm1::tests::expm1_gpu_provider_roundtrip"
+    },
+    "description": "`Y = expm1(X)` evaluates `exp(X) - 1` element-wise while maintaining high accuracy for values of `X` that are close to zero. It mirrors MATLAB semantics across scalars, vectors, matrices, logical arrays, character arrays, and complex inputs.",
+    "behaviors": [
+        "Logical inputs are promoted to double precision (`true -> 1.0`, `false -> 0.0`) before execution.",
+        "Character arrays are interpreted as their numeric code points and return dense double tensors.",
+        "Complex values follow MATLAB's definition by computing `exp(z) - 1` using complex arithmetic.",
+        "Existing GPU tensors remain on the device when the registered provider implements `unary_expm1`; otherwise RunMat gathers the data, computes on the CPU, and returns the result."
+    ],
+    "examples": [
+        {
+            "description": "Maintaining precision for tiny growth rates",
+            "input": "x = 1e-12;\ny = expm1(x)",
+            "output": "y = 1.0000000000005e-12"
+        },
+        {
+            "description": "Applying expm1 to model percentage growth",
+            "input": "rates = [-0.10 -0.05 0 0.05 0.10];\nfactors = expm1(rates)",
+            "output": "factors = [-0.0952 -0.0488 0 0.0513 0.1052]"
+        },
+        {
+            "description": "Running expm1 on GPU arrays",
+            "input": "G = gpuArray(linspace(-1, 1, 5));\nresult = expm1(G);\nout = gather(result)",
+            "output": "out = [-0.6321 -0.3935 0 0.6487 1.7183]"
+        },
+        {
+            "description": "Using expm1 with complex numbers",
+            "input": "z = [1+1i, -1+pi*1i];\nw = expm1(z)",
+            "output": "w = [0.4687 + 2.2874i, -1.3679 + 0.0000i]"
+        },
+        {
+            "description": "Applying expm1 to character data",
+            "input": "C = 'ABC';\nY = expm1(C)",
+            "output": "Y = [1.6949e+28 4.6072e+28 1.2524e+29]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I prefer `expm1` over `exp(x) - 1`?",
+            "answer": "Use `expm1` whenever `x` can be very close to zero. It avoids catastrophic cancellation and matches MATLAB's high-accuracy results for tiny magnitudes."
+        },
+        {
+            "question": "Does `expm1` change my tensor's shape?",
+            "answer": "No. The output has the same shape as the input, subject to MATLAB broadcasting semantics."
+        },
+        {
+            "question": "How are logical arrays handled?",
+            "answer": "Logical values convert to doubles before applying `expm1`, so `expm1([true false])` yields a double array `[e - 1, 0]`."
+        },
+        {
+            "question": "What about complex inputs?",
+            "answer": "Complex scalars and tensors use MATLAB's complex exponential formula and subtract one from the result, keeping both real and imaginary parts accurate."
+        },
+        {
+            "question": "What happens if the GPU provider lacks `unary_expm1`?",
+            "answer": "RunMat gathers the tensor to the host, computes with double precision, and returns the correct result. Subsequent fused kernels still see accurate residency metadata."
+        },
+        {
+            "question": "Can I expect double precision?",
+            "answer": "Yes. RunMat stores dense numeric tensors in double precision (`f64`). GPU providers may choose single precision internally but convert back to double when returning data to the runtime."
+        },
+        {
+            "question": "How does `expm1` interact with fusion?",
+            "answer": "The fusion planner recognises `expm1` as an element-wise op. Providers that support fused kernels can materialise `expm1` directly in generated WGSL."
+        }
+    ],
+    "links": [
+        {
+            "label": "exp",
+            "url": "./exp"
+        },
+        {
+            "label": "log1p",
+            "url": "./log1p"
+        },
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "abs",
+            "url": "./abs"
+        },
+        {
+            "label": "angle",
+            "url": "./angle"
+        },
+        {
+            "label": "conj",
+            "url": "./conj"
+        },
+        {
+            "label": "double",
+            "url": "./double"
+        },
+        {
+            "label": "factorial",
+            "url": "./factorial"
+        },
+        {
+            "label": "gamma",
+            "url": "./gamma"
+        },
+        {
+            "label": "hypot",
+            "url": "./hypot"
+        },
+        {
+            "label": "imag",
+            "url": "./imag"
+        },
+        {
+            "label": "ldivide",
+            "url": "./ldivide"
+        },
+        {
+            "label": "log",
+            "url": "./log"
+        },
+        {
+            "label": "log10",
+            "url": "./log10"
+        },
+        {
+            "label": "log2",
+            "url": "./log2"
+        },
+        {
+            "label": "minus",
+            "url": "./minus"
+        },
+        {
+            "label": "plus",
+            "url": "./plus"
+        },
+        {
+            "label": "pow2",
+            "url": "./pow2"
+        },
+        {
+            "label": "power",
+            "url": "./power"
+        },
+        {
+            "label": "rdivide",
+            "url": "./rdivide"
+        },
+        {
+            "label": "real",
+            "url": "./real"
+        },
+        {
+            "label": "sign",
+            "url": "./sign"
+        },
+        {
+            "label": "single",
+            "url": "./single"
+        },
+        {
+            "label": "sqrt",
+            "url": "./sqrt"
+        },
+        {
+            "label": "times",
+            "url": "./times"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/elementwise/expm1.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/expm1.rs"
+    },
+    "gpu_residency": "In most workflows you do **not** need to call `gpuArray` manually. RunMat's auto-offload planner and fusion engine keep data on the GPU when beneficial. You can still call `gpuArray` to mirror MathWorks MATLAB workflows or to pin data on the device explicitly.",
+    "gpu_behavior": [
+        "RunMat Accelerate keeps tensors resident on the GPU whenever the provider exposes the `unary_expm1` hook. When the hook is missing or errors, RunMat automatically gathers the tensor, performs the computation on the host using `f64::expm1` for the real components, and returns the result while preserving residency metadata. This ensures users always observe MATLAB-compatible behaviour without manual residency management."
+    ],
+    "key": "expm1",
+    "slug": "expm1",
+    "categoryPath": [
+        "math",
+        "elementwise"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=expm1.js.map

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

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

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

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

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

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

package/dist/generated/builtins/extractBetween.js

@@ -0,0 +1,182 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "extractBetween",
+    "category": "strings/transform",
+    "keywords": [
+        "extractBetween",
+        "substring",
+        "boundaries",
+        "inclusive",
+        "exclusive",
+        "string array"
+    ],
+    "summary": "Extract text that lies between two boundary markers using string or position inputs.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/extractbetween.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "matlab",
+        "notes": "Runs on the CPU. GPU-resident inputs are gathered before processing, results stay on the host, and the builtin is registered as an Accelerate sink."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::transform::extractbetween::tests",
+        "integration": "builtins::strings::transform::extractbetween::tests::extractBetween_cell_array_preserves_types"
+    },
+    "description": "`extractBetween(text, start, stop)` locates the substring that appears between two boundary markers. Markers can be text (string scalars, character vectors, or cells that contain them) or numeric positions. The builtin mirrors MATLAB semantics for broadcasting, missing values, and the optional `'Boundaries'` name-value argument.",
+    "behaviors": [
+        "Accepts **string scalars**, **string arrays**, **character arrays** (interpreted row-by-row), and **cell arrays** that contain string scalars or character vectors. Cell outputs preserve the element type (string vs. char) of each cell.",
+        "Boundary inputs can be text or numeric positions. Both boundaries in a call must use the same kind of input; mixing text and numeric markers raises a size/type error.",
+        "Scalar text markers follow MATLAB implicit expansion, applying to every element of the text input. Character-array and cell inputs must exactly match the text shape.",
+        "The `'Boundaries'` name-value pair controls inclusivity. Text markers default to **exclusive** extraction, while numeric positions default to **inclusive** behaviour. Values are case-insensitive and must be `'exclusive'` or `'inclusive'`.",
+        "Missing string scalars propagate: if the text, start marker, or end marker is `<missing>`, the result is also `<missing>`.",
+        "When the start or end boundary cannot be located, `extractBetween` returns an empty string (or an appropriately padded empty row for character arrays).",
+        "Numeric positions use 1-based indexing. Inputs are validated as positive integers, clamped to string length, and honour inclusivity rules exactly as MATLAB does."
+    ],
+    "examples": [
+        {
+            "description": "Extract text between words in a string",
+            "input": "txt = \"RunMat accelerates MATLAB workloads\";\nsegment = extractBetween(txt, \"RunMat \", \" workloads\")",
+            "output": "segment = \"accelerates MATLAB\""
+        },
+        {
+            "description": "Include boundary markers with the `'Boundaries'` option",
+            "input": "path = \"snapshots/run/fusion.mat\";\nwithMarkers = extractBetween(path, \"snapshots/\", \".mat\", \"Boundaries\", \"inclusive\")",
+            "output": "withMarkers = \"snapshots/run/fusion.mat\""
+        },
+        {
+            "description": "Use numeric positions for 1-based indexing",
+            "input": "name = \"Accelerator\";\nmiddle = extractBetween(name, 3, 7)",
+            "output": "middle = \"celer\""
+        },
+        {
+            "description": "Apply scalar text markers to each element of a string array",
+            "input": "files = [\"runmat_accel.rs\", \"runmat_gc.rs\"; \"runmat_plot.rs\", \"runmat_cli.rs\"];\nstems = extractBetween(files, \"runmat_\", \".rs\")",
+            "output": "stems = 2×2 string\n    \"accel\"    \"gc\"\n    \"plot\"     \"cli\""
+        },
+        {
+            "description": "Work with character arrays while preserving row padding",
+            "input": "chars = char(\"Device<GPU>\", \"Planner<Fusion>\");\ntokens = extractBetween(chars, \"<\", \">\")",
+            "output": "tokens =\n\n  2×6 char array\n\n    \"GPU   \"\n    \"Fusion\""
+        },
+        {
+            "description": "Preserve element types in cell arrays",
+            "input": "C = {'<missing>', 'A[B]C'; \"Planner <Fusion>\", \"Device<GPU>\"};\nout = extractBetween(C, \"<\", \">\")",
+            "output": "out =\n  2×2 cell array\n    {'<missing>'}    {'B'}\n    {\"Fusion\"}       {\"GPU\"}"
+        },
+        {
+            "description": "Handle missing strings without throwing errors",
+            "input": "txt = [\"<missing>\", \"Planner<GPU>\"];\ntokens = extractBetween(txt, \"<\", \">\")",
+            "output": "tokens = 1×2 string\n    \"<missing>\"    \"GPU\""
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Which argument types does `extractBetween` accept?",
+            "answer": "The first argument can be a string scalar, string array, character array, or cell array of character vectors / string scalars. Boundary arguments can be text (string, character array, or cell) or numeric positions supplied as scalars, vectors, or arrays."
+        },
+        {
+            "question": "Can the start and end arguments mix text and numeric positions?",
+            "answer": "No. Both boundaries must be text markers or both must be numeric positions. Mixing types raises a size/type error, mirroring MATLAB."
+        },
+        {
+            "question": "What happens when a boundary is not found?",
+            "answer": "`extractBetween` returns the empty string (`\"\"`). Character-array outputs contain space padded rows of the appropriate length."
+        },
+        {
+            "question": "How does `'Boundaries','inclusive'` behave with numeric positions?",
+            "answer": "Inclusive mode returns the substring that includes both indices. Exclusive mode removes the characters at the specified start and end positions, yielding the text strictly between the two indices."
+        },
+        {
+            "question": "Does `extractBetween` support implicit expansion?",
+            "answer": "Yes. Scalar boundaries expand against array inputs following MATLAB implicit expansion rules. Cell and character array inputs must retain their original shape; attempting to expand them produces a size mismatch error."
+        },
+        {
+            "question": "Are GPU inputs supported?",
+            "answer": "Yes. Inputs stored on a GPU are gathered automatically. The function executes on the CPU, returns host-side results, and fusion planning treats the builtin as a residency sink."
+        }
+    ],
+    "links": [
+        {
+            "label": "replace",
+            "url": "./replace"
+        },
+        {
+            "label": "split",
+            "url": "./split"
+        },
+        {
+            "label": "join",
+            "url": "./join"
+        },
+        {
+            "label": "contains",
+            "url": "./contains"
+        },
+        {
+            "label": "strfind",
+            "url": "./strfind"
+        },
+        {
+            "label": "erase",
+            "url": "./erase"
+        },
+        {
+            "label": "eraseBetween",
+            "url": "./erasebetween"
+        },
+        {
+            "label": "lower",
+            "url": "./lower"
+        },
+        {
+            "label": "pad",
+            "url": "./pad"
+        },
+        {
+            "label": "strcat",
+            "url": "./strcat"
+        },
+        {
+            "label": "strip",
+            "url": "./strip"
+        },
+        {
+            "label": "strrep",
+            "url": "./strrep"
+        },
+        {
+            "label": "strtrim",
+            "url": "./strtrim"
+        },
+        {
+            "label": "upper",
+            "url": "./upper"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/transform/extractbetween.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/transform/extractbetween.rs"
+    },
+    "gpu_behavior": [
+        "Text manipulation executes on the CPU. When any argument resides on the GPU, RunMat gathers the values to host memory, performs extraction, and leaves the results on the host. No Accelerate provider hooks are required, and the builtin is registered as an Accelerate sink so fusion plans never attempt to keep data on the device for this operation."
+    ],
+    "key": "extractbetween",
+    "slug": "extractbetween",
+    "categoryPath": [
+        "strings",
+        "transform"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=extractBetween.js.map

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

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

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

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

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

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

package/dist/generated/builtins/eye.js

@@ -0,0 +1,197 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "eye",
+    "category": "array/creation",
+    "keywords": [
+        "eye",
+        "identity",
+        "matrix",
+        "gpu",
+        "like",
+        "logical"
+    ],
+    "summary": "Create identity matrices and N-D identity tensors.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Uses provider identity allocation hooks when available; otherwise materialises the identity tensor on the host and uploads it."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::creation::eye::tests",
+        "integration": "builtins::array::creation::eye::tests::eye_gpu_like_alloc"
+    },
+    "description": "`eye` creates identity matrices (and higher-dimensional identity tensors) containing ones along the leading diagonal and zeros everywhere else. RunMat mirrors MATLAB semantics across scalar, vector, matrix, and N-D inputs, including `'logical'` and `'like'` options.",
+    "behaviors": [
+        "`eye()` returns the scalar `1`.",
+        "`eye(n)` returns an `n × n` double-precision identity matrix.",
+        "`eye(m, n, ...)` returns an `m × n × ...` tensor whose first two dimensions form an identity slice that is replicated across all trailing dimensions.",
+        "`eye(sz)` accepts a size vector (row or column) and returns an array with `size(I) == sz`.",
+        "`eye(A)` matches the size of `A`. Logical, complex, and GPU prototypes preserve their logical/complex/device traits; other inputs default to double precision for MATLAB parity.",
+        "`eye(___, 'logical')` returns a logical identity tensor instead of double precision.",
+        "`eye(___, 'like', prototype)` matches the numeric flavour and device residency of `prototype`, including GPU handles."
+    ],
+    "examples": [
+        {
+            "description": "Creating a 3-by-3 identity matrix",
+            "input": "I = eye(3)",
+            "output": "I =\n     1     0     0\n     0     1     0\n     0     0     1"
+        },
+        {
+            "description": "Generating a rectangular identity matrix",
+            "input": "J = eye(2, 4)",
+            "output": "J =\n     1     0     0     0\n     0     1     0     0"
+        },
+        {
+            "description": "Replicating an identity matrix across pages",
+            "input": "K = eye(2, 3, 2)   % Two 2x3 identity slices stacked along the third dimension",
+            "output": "K(:, :, 1) =\n     1     0     0\n     0     1     0\n\nK(:, :, 2) =\n     1     0     0\n     0     1     0"
+        },
+        {
+            "description": "Creating a logical identity mask",
+            "input": "mask = eye(4, 'logical')",
+            "output": "mask =\n     1     0     0     0\n     0     1     0     0\n     0     0     1     0\n     0     0     0     1"
+        },
+        {
+            "description": "Matching type and residency with `'like'`",
+            "input": "G = gpuArray(rand(128));     % Prototype on the GPU\nI = eye(size(G, 1), 'like', G)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I use the `eye` function?",
+            "answer": "Use `eye` whenever you need an identity matrix—for example, when solving linear systems, creating initial values for iterative methods, or building block-diagonal structures."
+        },
+        {
+            "question": "Does `eye` produce double arrays by default?",
+            "answer": "Yes. Unless you request `'logical'` or use `'like'`, the result is a dense double-precision array."
+        },
+        {
+            "question": "How do I create an identity matrix that matches another array's type or residency?",
+            "answer": "Use the `'like'` syntax: `I = eye(size(A, 1), 'like', A);`. The result adopts the same type and device residency as `A`."
+        },
+        {
+            "question": "Can `eye` generate higher-dimensional identity tensors?",
+            "answer": "Yes. Extra dimensions replicate the identity slice. For example, `eye(2, 3, 4)` creates four `2 × 3` identity matrices stacked along the third dimension."
+        },
+        {
+            "question": "What happens if I request zero-sized dimensions?",
+            "answer": "If any leading dimension is zero, the result contains zero elements (consistent with MATLAB)."
+        },
+        {
+            "question": "Is single precision supported?",
+            "answer": "Not yet. Requesting `'single'` currently reports an error. Use `'like'` with a single-precision prototype once single-precision support lands."
+        },
+        {
+            "question": "Does `eye(A)` match the class of `A`?",
+            "answer": "For logical, complex, and GPU prototypes, yes—`eye(A)` behaves like `eye(size(A), 'like', A)`. Other numeric inputs produce double precision to mirror MATLAB's default."
+        },
+        {
+            "question": "How efficient is the GPU path?",
+            "answer": "Providers with dedicated identity allocation avoid host involvement entirely. Providers without the hook fall back to a single host upload, which is still efficient for typical sizes."
+        }
+    ],
+    "links": [
+        {
+            "label": "zeros",
+            "url": "./zeros"
+        },
+        {
+            "label": "ones",
+            "url": "./ones"
+        },
+        {
+            "label": "diag",
+            "url": "./diag"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "colon",
+            "url": "./colon"
+        },
+        {
+            "label": "false",
+            "url": "./false"
+        },
+        {
+            "label": "fill",
+            "url": "./fill"
+        },
+        {
+            "label": "linspace",
+            "url": "./linspace"
+        },
+        {
+            "label": "logspace",
+            "url": "./logspace"
+        },
+        {
+            "label": "magic",
+            "url": "./magic"
+        },
+        {
+            "label": "meshgrid",
+            "url": "./meshgrid"
+        },
+        {
+            "label": "rand",
+            "url": "./rand"
+        },
+        {
+            "label": "randi",
+            "url": "./randi"
+        },
+        {
+            "label": "randn",
+            "url": "./randn"
+        },
+        {
+            "label": "randperm",
+            "url": "./randperm"
+        },
+        {
+            "label": "range",
+            "url": "./range"
+        },
+        {
+            "label": "true",
+            "url": "./true"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/creation/eye.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/creation/eye.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` yourself in RunMat. The fusion planner keeps data on the GPU whenever it determines that downstream work will benefit from staying on the device. The `eye` builtin respects that residency: if the planner or user requests GPU output (via `'like'`), it will either construct the identity tensor directly on the device (when the provider implements `eye`) or generate it on the host and upload it as a single transfer.",
+    "gpu_behavior": [
+        "When the result should live on a GPU (either because the prototype is a GPU tensor or the `'like'` argument references one), RunMat first asks the active acceleration provider for an identity buffer via the `eye` / `eye_like` hooks. The WGPU backend implements these hooks directly; simpler providers may return `Err`, in which case the runtime materialises the identity tensor on the host, performs a single upload, and returns a `GpuTensorHandle`. Because the allocation happens in one step, the auto-offload planner can keep subsequent fused expressions resident on the device without extra gathers."
+    ],
+    "key": "eye",
+    "slug": "eye",
+    "categoryPath": [
+        "array",
+        "creation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=eye.js.map

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

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

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

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

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

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