runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/dlmwrite.js

@@ -0,0 +1,180 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "dlmwrite",
+    "category": "io/tabular",
+    "keywords": [
+        "dlmwrite",
+        "delimiter",
+        "precision",
+        "newline",
+        "append",
+        "roffset",
+        "coffset"
+    ],
+    "summary": "Write numeric matrices to delimiter-separated text files with MATLAB-compatible precision and offset controls.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/dlmwrite.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs entirely on the CPU. gpuArray inputs are gathered before serialisation following MATLAB semantics."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::io::tabular::dlmwrite::tests",
+        "integration": [
+            "builtins::io::tabular::dlmwrite::tests::dlmwrite_writes_default_comma",
+            "builtins::io::tabular::dlmwrite::tests::dlmwrite_accepts_positional_delimiter_and_offsets",
+            "builtins::io::tabular::dlmwrite::tests::dlmwrite_supports_append_and_offsets",
+            "builtins::io::tabular::dlmwrite::tests::dlmwrite_precision_digits",
+            "builtins::io::tabular::dlmwrite::tests::dlmwrite_precision_format_string",
+            "builtins::io::tabular::dlmwrite::tests::dlmwrite_newline_pc",
+            "builtins::io::tabular::dlmwrite::tests::dlmwrite_coffset_inserts_empty_fields",
+            "builtins::io::tabular::dlmwrite::tests::dlmwrite_handles_gpu_tensors",
+            "builtins::io::tabular::dlmwrite::tests::dlmwrite_interprets_control_sequence_delimiters",
+            "builtins::io::tabular::dlmwrite::tests::dlmwrite_handles_wgpu_provider_gather",
+            "builtins::io::tabular::dlmwrite::tests::dlmwrite_rejects_negative_offsets",
+            "builtins::io::tabular::dlmwrite::tests::dlmwrite_rejects_empty_delimiter",
+            "builtins::io::tabular::dlmwrite::tests::dlmwrite_precision_zero_error"
+        ]
+    },
+    "description": "`dlmwrite(filename, M)` writes the numeric contents of `M` to a plain text file using a configurable delimiter. It is MATLAB's legacy companion to `csvwrite`, adding support for custom delimiters, per-call precision, line endings, and zero-based row/column offsets. RunMat mirrors these semantics so that existing MATLAB scripts continue to behave identically.",
+    "behaviors": [
+        "Accepts real numeric or logical arrays up to two dimensions (trailing singleton dimensions are ignored). Complex inputs raise an error. Logical values are converted to `0`/`1`.",
+        "The default delimiter is a comma. Supply a character vector, string scalar, or control sequence (`\"\\t\"`, `\"\\n\"`, `\"\\r\"`) to change it. Delimiters must not be empty.",
+        "Positional syntax matches MATLAB: `dlmwrite(filename, M, delimiter)` and `dlmwrite(filename, M, delimiter, row, col)` provide quick overrides. Row/column offsets are zero-based and insert blank rows/columns filled with the delimiter before the numeric data.",
+        "Name-value pairs extend any syntax: `'-append'` appends to an existing file, `'delimiter'` overrides the separator, `'precision'` accepts either a scalar (significant digits) or a C-style printf format such as `'%.6f'`, `'newline'` chooses between `'pc'` (`CRLF`), `'unix'` (`LF`), or `'mac'` (`CR`), and `'roffset'`/`'coffset'` mirror the positional offsets.",
+        "Empty fields created by offsets are emitted as empty tokens separated by the delimiter, matching MATLAB's behaviour.",
+        "Files are opened in text mode. When appending, RunMat preserves the existing newline convention and honours offsets relative to the end of the file.",
+        "Paths beginning with `~` expand to the user's home directory before writing, matching other RunMat I/O builtins."
+    ],
+    "examples": [
+        {
+            "description": "Writing a numeric matrix with the default comma delimiter",
+            "input": "A = [1 2 3; 4 5 6];\ndlmwrite(\"scores.csv\", A)"
+        },
+        {
+            "description": "Using a semicolon delimiter and positional offsets",
+            "input": "B = magic(3);\ndlmwrite(\"offset.txt\", B, \";\", 1, 2)"
+        },
+        {
+            "description": "Appending data with explicit row and column offsets",
+            "input": "dlmwrite(\"log.txt\", 1:3);\ndlmwrite(\"log.txt\", 10:12, \"-append\", \"roffset\", 1, \"coffset\", 1)"
+        },
+        {
+            "description": "Controlling precision with significant digits",
+            "input": "vals = [12.34567, pi];\ndlmwrite(\"precision3.csv\", vals, \"precision\", 3)"
+        },
+        {
+            "description": "Emitting fixed-point values with a printf-style format string",
+            "input": "dlmwrite(\"fixed.txt\", rand(2, 2), \"precision\", \"%.6f\", \"delimiter\", \"\\t\")"
+        },
+        {
+            "description": "Selecting the Windows line ending while writing GPU data",
+            "input": "G = gpuArray(single([1.5; 2.5; 3.5]));\ndlmwrite(\"gpu_pc.txt\", G, \"newline\", \"pc\")",
+            "output": "% Data is gathered from the GPU and written using CR/LF line endings."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Which data types does `dlmwrite` support?",
+            "answer": "Real numeric and logical arrays up to two dimensions. Use `writematrix`/`writecell` for text or heterogeneous data."
+        },
+        {
+            "question": "How does the `'-append'` flag interact with offsets?",
+            "answer": "Offsets are applied relative to the end of the existing file. `'-append','roffset',2` inserts two blank delimiter-filled rows before writing the new data."
+        },
+        {
+            "question": "What happens if I request both positional and name-value offsets?",
+            "answer": "RunMat follows MATLAB by allowing both; the last specification wins. For clarity, prefer one style per call."
+        },
+        {
+            "question": "Can I combine `'-append'` with positional delimiter arguments?",
+            "answer": "Yes. For example `dlmwrite(fname, M, ';', '-append')` uses the semicolon delimiter and appends to the file."
+        },
+        {
+            "question": "Does `'precision', N` control decimal places or significant digits?",
+            "answer": "It controls significant digits (like MATLAB's `%.*g`). For fixed decimal places, pass a printf-style format such as `'%.6f'`."
+        },
+        {
+            "question": "Which line endings are supported?",
+            "answer": "`'newline','pc'` emits `\\r\\n` (Windows). `'newline','unix'` emits `\\n`, and `'newline','mac'` emits `\\r`. The default matches the current platform."
+        },
+        {
+            "question": "How are NaN and Inf values written?",
+            "answer": "They are emitted verbatim as `NaN`, `Inf`, or `-Inf`, independent of the precision setting, matching MATLAB."
+        },
+        {
+            "question": "How are offsets represented in the file?",
+            "answer": "`roffset` produces blank delimiter-separated rows, while `coffset` inserts empty fields before each data row. Downstream tools will see empty strings for the offset cells."
+        },
+        {
+            "question": "Does `dlmwrite` normalise path separators?",
+            "answer": "No. Paths are passed directly to the OS after optional `~` expansion, exactly like MATLAB."
+        },
+        {
+            "question": "Should new code use `dlmwrite`?",
+            "answer": "Prefer `writematrix` for new code. Use `dlmwrite` only when maintaining legacy scripts that rely on its exact output."
+        }
+    ],
+    "links": [
+        {
+            "label": "dlmread",
+            "url": "./dlmread"
+        },
+        {
+            "label": "csvwrite",
+            "url": "./csvwrite"
+        },
+        {
+            "label": "writematrix",
+            "url": "./writematrix"
+        },
+        {
+            "label": "fprintf",
+            "url": "./fprintf"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "csvread",
+            "url": "./csvread"
+        },
+        {
+            "label": "readmatrix",
+            "url": "./readmatrix"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/io/tabular/dlmwrite.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/tabular/dlmwrite.rs"
+    },
+    "gpu_residency": "No. `dlmwrite` gathers GPU-resident tensors automatically before writing. This mirrors MATLAB's behaviour, where `dlmwrite` always operates on host-resident values.",
+    "gpu_behavior": [
+        "`dlmwrite` performs all formatting on the CPU. When the input array lives on a GPU, RunMat gathers it through the active acceleration provider before serialisation. No provider hooks are required, and the builtin returns once the host-side write completes. If no provider is registered, the same gather error surface as other residency sinks appears."
+    ],
+    "key": "dlmwrite",
+    "slug": "dlmwrite",
+    "categoryPath": [
+        "io",
+        "tabular"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=dlmwrite.js.map

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

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

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

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

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

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

package/dist/generated/builtins/dot.js

@@ -0,0 +1,163 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "dot",
+    "category": "math/linalg/ops",
+    "keywords": [
+        "dot",
+        "inner product",
+        "linear algebra",
+        "gpu",
+        "dimension"
+    ],
+    "summary": "Compute dot products (inner products) of real or complex inputs, optionally along a chosen dimension.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/dot.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": true,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Prefers a provider-side dot hook; the WGPU backend currently handles 2-D tensors along dimensions 1 or 2 and falls back to the host otherwise. When no hook is available RunMat gathers operands, evaluates the MATLAB reference path, and re-uploads real results when possible."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::linalg::ops::dot::tests",
+        "integration": "builtins::math::linalg::ops::dot::tests::dot_gpu_roundtrip"
+    },
+    "description": "`dot(A, B)` evaluates the inner product between matching slices of `A` and `B`. Inputs must have the same size, and complex vectors follow MATLAB's convention `sum(conj(A) .* B)`.",
+    "behaviors": [
+        "Treats vectors, matrices, and N-D tensors identically as long as `A` and `B` share the same size.",
+        "When no dimension is supplied, the function reduces along the first non-singleton dimension (`dim = 1` when all dimensions are singleton).",
+        "`dot(A, B, dim)` collapses dimension `dim` (1-based) while leaving every other dimension untouched.",
+        "Complex inputs conjugate the first argument before multiplication; real inputs use a straight element-wise product.",
+        "Empty reductions yield zeros of the appropriate shape; length mismatches raise `A and B must be the same size`.",
+        "Logical and integer inputs are promoted to double precision automatically so the result is always floating point (or complex when any input is complex)."
+    ],
+    "examples": [
+        {
+            "description": "Computing the dot product of row vectors",
+            "input": "A = [1 2 3];\nB = [4 5 6];\nval = dot(A, B)",
+            "output": "val = 32"
+        },
+        {
+            "description": "Dotting column vectors to obtain a scalar",
+            "input": "u = [1; 3; 5];\nv = [2; 4; 6];\nval = dot(u, v)",
+            "output": "val = 44"
+        },
+        {
+            "description": "Applying `dot` along a chosen dimension",
+            "input": "X = [1 2 3; 4 5 6];\nY = [6 5 4; 3 2 1];\ncols = dot(X, Y, 1)  % collapse rows\nrows = dot(X, Y, 2)  % collapse columns",
+            "output": "cols = [18 20 18];\nrows = [28; 28]"
+        },
+        {
+            "description": "Dotting complex vectors uses conjugation on the first input",
+            "input": "a = [1+2i, 3-4i];\nb = [2-3i, -1+5i];\nval = dot(a, b)",
+            "output": "val = -27 + 4i"
+        },
+        {
+            "description": "Evaluating `dot` on `gpuArray` inputs",
+            "input": "G1 = gpuArray([1 2 3 4]);\nG2 = gpuArray([4 3 2 1]);\nG = dot(G1, G2);\nresult = gather(G)",
+            "output": "result = 20"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `dot` require vectors?",
+            "answer": "No. Any pair of tensors with identical sizes works; specifying a dimension lets you dot slices of higher-dimensional arrays."
+        },
+        {
+            "question": "How does the optional dimension behave?",
+            "answer": "`dot(A, B, dim)` collapses the `dim`th dimension (1-based). Dimensions greater than the array rank have length 1 and therefore leave the data unchanged."
+        },
+        {
+            "question": "What happens with complex numbers?",
+            "answer": "The first input is conjugated before multiplication so the result matches MATLAB's hermitian inner product."
+        },
+        {
+            "question": "Are empty inputs supported?",
+            "answer": "Yes. If the reduction dimension has length 0 the result is filled with zeros of the appropriate shape."
+        },
+        {
+            "question": "Will the result stay on the GPU?",
+            "answer": "When a provider is active the runtime uploads real-valued results back to the device. Complex outputs stay on the host until GPU complex support is available."
+        },
+        {
+            "question": "What error is raised for size mismatches?",
+            "answer": "When `A` and `B` differ in size `dot` raises: `A and B must be the same size.` matching MATLAB's wording."
+        },
+        {
+            "question": "Does `dot` accept logical or integer inputs?",
+            "answer": "Yes. Inputs are promoted to double precision before evaluation so you never lose MATLAB's semantics."
+        },
+        {
+            "question": "Can I request conjugation of the second argument instead?",
+            "answer": "No. MATLAB's `dot` is fixed to conjugate the first argument. Use `sum(A .* conj(B))` manually if you need the opposite orientation."
+        }
+    ],
+    "links": [
+        {
+            "label": "mtimes",
+            "url": "./mtimes"
+        },
+        {
+            "label": "mldivide",
+            "url": "./mldivide"
+        },
+        {
+            "label": "norm",
+            "url": "./norm"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "ctranspose",
+            "url": "./ctranspose"
+        },
+        {
+            "label": "mpower",
+            "url": "./mpower"
+        },
+        {
+            "label": "mrdivide",
+            "url": "./mrdivide"
+        },
+        {
+            "label": "trace",
+            "url": "./trace"
+        },
+        {
+            "label": "transpose",
+            "url": "./transpose"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/linalg/ops/dot.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/linalg/ops/dot.rs"
+    },
+    "gpu_residency": "You rarely need to call `gpuArray` explicitly for `dot`. If the provider lacks a dedicated dot kernel, RunMat will gather the operands, compute the host result, and—when the output is real—upload it back to the provider automatically. Complex outputs remain on the host until GPU complex datatypes are implemented; in mixed pipelines consider reintroducing `gpuArray` explicitly after the call if residency is critical.",
+    "gpu_behavior": [
+        "RunMat Accelerate keeps GPU-resident tensors on the device whenever the active provider exposes a `dot` hook. When the hook is missing, RunMat gathers both operands to the host, evaluates the reference path, and—when the result is real—uploads it back to the provider so downstream GPU code continues without manual transfers. Complex outputs remain on the host until provider support lands."
+    ],
+    "key": "dot",
+    "slug": "dot",
+    "categoryPath": [
+        "math",
+        "linalg",
+        "ops"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=dot.js.map

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

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

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

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

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

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

package/dist/generated/builtins/double.js

@@ -0,0 +1,240 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "double",
+    "category": "math/elementwise",
+    "keywords": [
+        "double",
+        "float64",
+        "cast",
+        "convert to double",
+        "gpuArray double"
+    ],
+    "summary": "Convert numeric values, logical masks, characters, and gpuArray handles to double precision.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/double.html"
+    ],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Prefers the provider's `unary_double` hook on float64-capable backends; gathers to the host when the GPU cannot represent doubles and only re-uploads when supported."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": "wgpu",
+    "tested": {
+        "unit": "builtins::math::elementwise::double::tests",
+        "gpu": "builtins::math::elementwise::double::tests::double_gpu_roundtrip",
+        "wgpu": "builtins::math::elementwise::double::tests::double_wgpu_matches_cpu"
+    },
+    "description": "`double(X)` promotes scalars, arrays, complex values, logical masks, character data, and gpuArray handles to MATLAB’s default double-precision (`float64`) representation while preserving shapes and column-major layout.",
+    "behaviors": [
+        "Numeric inputs that are already double precision are returned unchanged; single-precision and integer values are promoted without altering shapes.",
+        "Logical inputs become dense double arrays containing `0` and `1`, matching MATLAB’s promotion rules used by arithmetic on logical masks.",
+        "Character arrays are converted to their Unicode code points and returned as doubles (`'A'` becomes `65`).",
+        "Complex scalars and arrays remain complex, but both components are stored as double precision.",
+        "Empty arrays stay empty, orientation is preserved, and singleton dimensions are untouched.",
+        "Strings, structs, cells, objects, and other unsupported classes raise MATLAB-style errors of the form `\"double: conversion to double from <type> is not possible\"`."
+    ],
+    "examples": [
+        {
+            "description": "Convert integers to double precision",
+            "input": "ints = int32([1 2 3]);\ndoubles = double(ints)",
+            "output": "doubles = [1 2 3]"
+        },
+        {
+            "description": "Promote logical masks for arithmetic",
+            "input": "mask = logical([0 1 0 1]);\nweights = double(mask)",
+            "output": "weights = [0 1 0 1]"
+        },
+        {
+            "description": "Convert character arrays to Unicode code points",
+            "input": "codes = double('RunMat')",
+            "output": "codes = [82 117 110 77 97 116]"
+        },
+        {
+            "description": "Preserve complex numbers while promoting precision",
+            "input": "z = [1+2i, 3-4i];\nresult = double(z)",
+            "output": "result = [1+2i  3-4i]"
+        },
+        {
+            "description": "Convert single-precision gpuArray data to double",
+            "input": "G = single(gpuArray(1:4));\nH = double(G);\ngather(H)",
+            "output": "ans = [1 2 3 4]"
+        },
+        {
+            "description": "Handle double precision with `'like'` prototypes",
+            "input": "proto = gpuArray.zeros(1, 1, 'double');\nout = double([pi 0], 'like', proto)",
+            "output": "out =\n  1×2 gpuArray  double\n    3.1416         0"
+        },
+        {
+            "description": "Promote matrices without changing shape",
+            "input": "A = single([1.5 2.25; 3.75 4.5]);\nB = double(A)",
+            "output": "B = [1.5 2.25; 3.75 4.5]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `double` change values that are already double precision?",
+            "answer": "No. Existing double data is passed through unchanged; the builtin only promotes other types."
+        },
+        {
+            "question": "How are logical inputs handled?",
+            "answer": "Logical masks become numeric 0/1 doubles, making it easy to apply arithmetic or linear algebra without extra casts."
+        },
+        {
+            "question": "What happens to NaN or Inf values?",
+            "answer": "IEEE special values survive promotion exactly. NaNs stay NaN, and ±Inf remain ±Inf."
+        },
+        {
+            "question": "Can I convert strings with `double`?",
+            "answer": "No. Strings are not implicitly convertible; convert them to character arrays first with `char` and then take `double`."
+        },
+        {
+            "question": "Will `double` keep results on the GPU?",
+            "answer": "Yes when the provider supports float64. Otherwise the runtime documents the gather fallback and returns a host tensor."
+        },
+        {
+            "question": "Does `double` allocate new memory?",
+            "answer": "Yes. Results are materialised in a new tensor or, for scalars, a new numeric value. Fusion may fold the cast with neighbouring elementwise operations."
+        },
+        {
+            "question": "Can I request GPU residency with `'like'`?",
+            "answer": "Yes. Pass `'like', prototype` to mirror the prototype’s residency. Provide a gpuArray prototype to keep the result on the device when the backend supports float64."
+        },
+        {
+            "question": "How does `double` interact with complex inputs?",
+            "answer": "Complex values keep both components intact; the builtin simply ensures they are stored as double precision."
+        }
+    ],
+    "links": [
+        {
+            "label": "single",
+            "url": "./single"
+        },
+        {
+            "label": "real",
+            "url": "./real"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "abs",
+            "url": "./abs"
+        },
+        {
+            "label": "angle",
+            "url": "./angle"
+        },
+        {
+            "label": "conj",
+            "url": "./conj"
+        },
+        {
+            "label": "exp",
+            "url": "./exp"
+        },
+        {
+            "label": "expm1",
+            "url": "./expm1"
+        },
+        {
+            "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": "log1p",
+            "url": "./log1p"
+        },
+        {
+            "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": "sign",
+            "url": "./sign"
+        },
+        {
+            "label": "sqrt",
+            "url": "./sqrt"
+        },
+        {
+            "label": "times",
+            "url": "./times"
+        }
+    ],
+    "source": {
+        "label": "crates/runmat-runtime/src/builtins/math/elementwise/double.rs",
+        "url": "crates/runmat-runtime/src/builtins/math/elementwise/double.rs"
+    },
+    "gpu_residency": "RunMat keeps tensors on the GPU whenever the active provider supports double precision. You only need explicit `gpuArray` / `gather` calls when interfacing with legacy code or when you must force residency. On float32-only providers, `double` returns host data, matching MATLAB systems where the GPU lacks native double support.",
+    "gpu_behavior": [
+        "RunMat first inspects the active acceleration provider:\n\n1. **Provider exposes float64 (double) precision:** gpuArray inputs are kept on device. The runtime downloads once only when the provider lacks a native cast primitive, performs the conversion on the host, and uploads the double-precision result back to the device, freeing the original handle. Providers may later add a `unary_double` hook to avoid the temporary host hop. 2. **Provider is float32-only:** gpuArray inputs are gathered to host memory because the backend cannot store double precision. The result is returned as a host tensor; subsequent operations can choose to re-upload if profitable. 3. **No provider registered:** gpuArray values behave like gathered host arrays, mirroring MATLAB’s behaviour when Parallel Computing Toolbox is absent.\n\nAll GPU fallbacks are documented so you know exactly when data leaves the device."
+    ],
+    "key": "double",
+    "slug": "double",
+    "categoryPath": [
+        "math",
+        "elementwise"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=double.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"double.js","sourceRoot":"","sources":["../../../src/generated/builtins/double.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,kBAAkB;IAC9B,UAAU,EAAE;QACV,QAAQ;QACR,SAAS;QACT,MAAM;QACN,mBAAmB;QACnB,iBAAiB;KAClB;IACD,SAAS,EAAE,8FAA8F;IACzG,YAAY,EAAE;QACZ,uDAAuD;KACxD;IACD,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,uKAAuK;KACjL;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,MAAM;IAC1B,QAAQ,EAAE;QACR,MAAM,EAAE,4CAA4C;QACpD,KAAK,EAAE,kEAAkE;QACzE,MAAM,EAAE,qEAAqE;KAC9E;IACD,aAAa,EAAE,4NAA4N;IAC3O,WAAW,EAAE;QACX,oJAAoJ;QACpJ,0IAA0I;QAC1I,2GAA2G;QAC3G,gGAAgG;QAChG,4FAA4F;QAC5F,uKAAuK;KACxK;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,gDAAgD;YACzD,QAAQ,EAAE,mBAAmB;SAC9B;QACD;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,oDAAoD;YAC7D,QAAQ,EAAE,qBAAqB;SAChC;QACD;YACE,aAAa,EAAE,iDAAiD;YAChE,OAAO,EAAE,0BAA0B;YACnC,QAAQ,EAAE,gCAAgC;SAC3C;QACD;YACE,aAAa,EAAE,oDAAoD;YACnE,OAAO,EAAE,uCAAuC;YAChD,QAAQ,EAAE,uBAAuB;SAClC;QACD;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,uDAAuD;YAChE,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,8EAA8E;YACvF,QAAQ,EAAE,qDAAqD;SAChE;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,kDAAkD;YAC3D,QAAQ,EAAE,0BAA0B;SACrC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,gEAAgE;YAC5E,QAAQ,EAAE,8FAA8F;SACzG;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,qHAAqH;SAChI;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,qFAAqF;SAChG;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,wHAAwH;SACnI;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,wHAAwH;SACnI;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,wJAAwJ;SACnK;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,qKAAqK;SAChL;QACD;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,6GAA6G;SACxH;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;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,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,+DAA+D;KACvE;IACD,eAAe,EAAE,0UAA0U;IAC3V,cAAc,EAAE;QACd,s4BAAs4B;KACv4B;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,cAAc,EAAE;QACd,MAAM;QACN,aAAa;KACd;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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