runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/acosh.js

@@ -0,0 +1,187 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "acosh",
+    "category": "math/trigonometry",
+    "keywords": [
+        "acosh",
+        "inverse hyperbolic cosine",
+        "arccosh",
+        "trigonometry",
+        "gpu",
+        "complex"
+    ],
+    "summary": "Element-wise inverse hyperbolic cosine with MATLAB-compatible complex promotion and GPU fallbacks.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Uses the provider's unary_acosh hook when every element stays within the real domain (x ≥ 1); gathers to the host when complex promotion is required or hooks are unavailable."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::trigonometry::acosh::tests",
+        "integration": "builtins::math::trigonometry::acosh::tests::acosh_gpu_provider_roundtrip"
+    },
+    "description": "`Y = acosh(X)` evaluates the inverse hyperbolic cosine of each element in `X`. Real inputs greater than or equal to `1` stay real; values below `1` automatically promote to complex results that match MATLAB's principal branch.",
+    "behaviors": [
+        "Accepts scalars, vectors, matrices, and N-D tensors with MATLAB broadcasting semantics.",
+        "Logical inputs are promoted to double precision (`true → 1`, `false → 0`) before evaluation.",
+        "Character arrays are interpreted as their numeric code points. If any element is less than `1`, the result becomes a complex array, mirroring MATLAB.",
+        "Real values in `[1, ∞)` return real outputs computed by `acosh`.",
+        "Real values in `(-∞, 1)` produce complex results: the runtime returns `Value::Complex` or `Value::ComplexTensor` so that downstream code sees the same behaviour as MATLAB.",
+        "Complex inputs follow MATLAB's definition `acosh(z) = \\log(z + \\sqrt{z-1}\\sqrt{z+1})`, including NaN/Inf handling on branch cuts.",
+        "Special values propagate exactly like MATLAB: `acosh(NaN) = NaN`, `acosh(Inf) = Inf`, and `acosh(-Inf) = Inf + i·π`."
+    ],
+    "examples": [
+        {
+            "description": "Inverse hyperbolic cosine of a scalar greater than one",
+            "input": "y = acosh(1.5)",
+            "output": "y = 0.9624"
+        },
+        {
+            "description": "Applying `acosh` to each element of a vector",
+            "input": "x = [1 1.5 2 4];\ny = acosh(x)",
+            "output": "y = [0 0.9624 1.31696 2.06344]"
+        },
+        {
+            "description": "Handling elements below one that produce complex results",
+            "input": "values = [0.5 1 2];\nz = acosh(values)",
+            "output": "z =\n   0.0000 + 1.0472i   0.0000 + 0.0000i   1.31696 + 0.0000i"
+        },
+        {
+            "description": "Computing `acosh` on GPU-resident data when the domain stays real",
+            "input": "G = gpuArray(linspace(1, 5, 5));\nresult_gpu = acosh(G);\nresult = gather(result_gpu)",
+            "output": "result = [0 1.31696 1.76274 2.06344 2.29243]"
+        },
+        {
+            "description": "Evaluating `acosh` for complex numbers",
+            "input": "z = [1 + 2i, -2 + 0.5i];\nw = acosh(z)",
+            "output": "w =\n   1.5286 + 1.1437i\n   1.3618 + 2.8638i"
+        },
+        {
+            "description": "Working with character arrays (mix of complex and real results)",
+            "input": "C = char([0 65]);   % includes a code point below 1\nY = acosh(C)",
+            "output": "Y =\n   0.0000 + 1.5708i   4.8675 + 0.0000i"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why does `acosh` sometimes return complex numbers?",
+            "answer": "The real-valued inverse hyperbolic cosine is only defined for `x ≥ 1`. Inputs below that range require complex results, so RunMat (like MATLAB) promotes them automatically."
+        },
+        {
+            "question": "Can `acosh` run entirely on the GPU?",
+            "answer": "Yes—when all elements are ≥ 1 and the provider implements `unary_acosh`, the runtime executes the operation on the GPU. Otherwise, it falls back to the host transparently."
+        },
+        {
+            "question": "How are NaN or Inf values handled?",
+            "answer": "`acosh(NaN)` returns `NaN`. Positive infinity stays real infinity. Negative infinity produces the same complex result as MATLAB (`Inf + i·π`)."
+        },
+        {
+            "question": "Do logical and integer inputs work?",
+            "answer": "Yes. They are promoted to double precision before evaluation. The output is a dense double (or complex double) array following MATLAB semantics."
+        },
+        {
+            "question": "Can I keep complex results on the GPU?",
+            "answer": "Currently, GPU tensors represent real data. When complex outputs are required, the runtime gathers to the host and returns `Value::Complex` / `Value::ComplexTensor` for correctness."
+        },
+        {
+            "question": "Does `acosh` participate in fusion?",
+            "answer": "Yes. The fusion planner treats `acosh` as an element-wise operation and can inline it into fused WGSL kernels when the provider supports the generated code."
+        },
+        {
+            "question": "What tolerance does the runtime use to decide GPU fallback?",
+            "answer": "Any element below `1` triggers a host fallback so the runtime can return the correct complex result. This mirrors MATLAB exactly instead of relying on GPU intrinsics that would otherwise yield `NaN`."
+        },
+        {
+            "question": "Can `acosh` be differentiated automatically?",
+            "answer": "Yes. Marking it as an element-wise builtin ensures future autodiff tooling can reuse the same metadata to generate gradients."
+        }
+    ],
+    "links": [
+        {
+            "label": "asinh",
+            "url": "./asinh"
+        },
+        {
+            "label": "tanh",
+            "url": "./tanh"
+        },
+        {
+            "label": "cosh",
+            "url": "./cosh"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "acos",
+            "url": "./acos"
+        },
+        {
+            "label": "asin",
+            "url": "./asin"
+        },
+        {
+            "label": "atan",
+            "url": "./atan"
+        },
+        {
+            "label": "atan2",
+            "url": "./atan2"
+        },
+        {
+            "label": "atanh",
+            "url": "./atanh"
+        },
+        {
+            "label": "cos",
+            "url": "./cos"
+        },
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "sinh",
+            "url": "./sinh"
+        },
+        {
+            "label": "tan",
+            "url": "./tan"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/trigonometry/acosh.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/trigonometry/acosh.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` manually. The auto-offload planner keeps tensors on the GPU whenever the provider exposes `unary_acosh` and the input stays within the real domain. When complex promotion is needed, RunMat gathers automatically and still returns MATLAB-compatible results. Manual `gpuArray` / `gather` remains available for workflows that require explicit residency control.",
+    "gpu_behavior": [
+        "RunMat Accelerate keeps tensors on the GPU when:\n\n1. A provider is registered and implements the `unary_acosh` hook. 2. Every element is provably within the real domain (that is, all elements ≥ 1). 3. All inputs are finite; NaN or `-Inf` values force a host fallback so complex promotion and branch-cut semantics remain correct.\n\nThe runtime calls `reduce_min` on the active provider to perform this domain check. If the provider does not expose the hook, the reduction fails, or any element violates the conditions above, RunMat falls back to the host, evaluates `acosh` with the CPU reference implementation, and returns results identical to MATLAB. This ensures correctness without forcing users to manually `gather` tensors."
+    ],
+    "key": "acosh",
+    "slug": "acosh",
+    "categoryPath": [
+        "math",
+        "trigonometry"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=acosh.js.map

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

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

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

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

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

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

package/dist/generated/builtins/addpath.js

@@ -0,0 +1,220 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "addpath",
+    "category": "io/repl_fs",
+    "keywords": [
+        "addpath",
+        "search path",
+        "matlab path",
+        "-begin",
+        "-end",
+        "-frozen"
+    ],
+    "summary": "Add folders to the MATLAB search path used by RunMat.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/addpath.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs entirely on the CPU. gpuArray text inputs are gathered automatically before processing."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 8,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::io::repl_fs::addpath::tests",
+        "integration": "builtins::io::repl_fs::addpath::tests::addpath_accepts_string_containers"
+    },
+    "description": "`addpath` prepends or appends folders to the MATLAB search path that RunMat consults when resolving functions, scripts, classes, and data files. The change affects the current session immediately, and the resulting ordering matches MATLAB semantics.",
+    "behaviors": [
+        "Folder arguments may be character vectors, string scalars, string arrays, or cell arrays of character vectors or strings. Multi-row char arrays contribute one folder per row (trailing padding is stripped).",
+        "Multiple folders can be passed in a single argument using the platform path separator (`:` on Linux/macOS, `;` on Windows); this is compatible with `genpath`.",
+        "By default, folders are added to the top of the search path. Use `'-end'` to append or `'-begin'` to force prepending explicitly. Only one position flag is permitted.",
+        "The `'-frozen'` flag is accepted for MATLAB compatibility. RunMat does not currently track frozen entries separately; the flag simply suppresses incompatibility warnings.",
+        "Duplicate entries are removed automatically so each folder appears at most once. On Windows, comparisons are case-insensitive.",
+        "Inputs are resolved to absolute, canonicalised paths. Relative inputs are interpreted relative to the current working directory, and `~` expands to the user’s home directory.",
+        "Folders must exist. RunMat raises `addpath: folder '<name>' not found` when a directory is missing or `addpath: '<name>' is not a folder` when the target is not a directory."
+    ],
+    "examples": [
+        {
+            "description": "Add a single folder to the top of the search path",
+            "input": "mkdir(\"util/toolbox\");\noldPath = path();\naddpath(\"util/toolbox\");\nnewPath = path();\ncount = fprintf('%s %s\\n', oldPath, newPath);",
+            "output": " /util/toolbox"
+        },
+        {
+            "description": "Append folders to the end of the search path",
+            "input": "mkdir(\"shared/filters\");\nmkdir(\"shared/signal\");\noldPath = path();\ndirs = [\"shared/filters\", \"shared/signal\"];\naddpath(dirs, \"-end\");\nnewPath = path();\ncount = fprintf('%s %s\\n', oldPath, newPath);",
+            "output": " /shared/filters:/shared/signal"
+        },
+        {
+            "description": "Use `genpath` output to add a folder tree",
+            "input": "mkdir(\"third_party/toolchain\");\nmkdir(\"third_party/toolchain/bin\");\noldPath = path();\ntoolchain = genpath(\"third_party/toolchain\");\naddpath(toolchain);\nnewPath = path();\ncount = fprintf('%s %s\\n', oldPath, newPath);",
+            "output": " /third_party/toolchain:/third_party/toolchain/bin"
+        },
+        {
+            "description": "Add folders from a cell array",
+            "input": "mkdir(\"src/algorithms\");\nmkdir(\"src/visualization\");\noldPath = path();\nfolders = [\"src/algorithms\", \"src/visualization\"];\naddpath(folders, \"-begin\");\nnewPath = path();\ncount = fprintf('%s %s\\n', oldPath, newPath);",
+            "output": " /src/algorithms:/src/visualization"
+        },
+        {
+            "description": "Move an existing folder to the top of the search path",
+            "input": "mkdir(\"src/algorithms\");\noldPath = path();\naddpath(\"src/algorithms\");\nnewPath = path();\ncount = fprintf('%s %s\\n', oldPath, newPath);",
+            "output": " /src/algorithms"
+        },
+        {
+            "description": "Accept the MATLAB `-frozen` flag",
+            "input": "mkdir(\"vendor/hardware\");\noldPath = path();\naddpath(\"vendor/hardware\", \"-frozen\");\nnewPath = path();\ncount = fprintf('%s %s\\n', oldPath, newPath);",
+            "output": " /vendor/hardware"
+        },
+        {
+            "description": "Retrieve the previous path and restore it later",
+            "input": "mkdir(\"analysis/utilities\");\noldPath = path();\nold = addpath(\"analysis/utilities\");\nnewPath = path();\npath(old);\ncount = fprintf('%s %s\\n', oldPath, newPath);",
+            "output": " /analysis/utilities"
+        },
+        {
+            "description": "Combine multiple options",
+            "input": "mkdir(\"contrib\");\nmkdir(\"docs/examples\");\noldPath = path();\naddpath(\"contrib\", \"docs/examples\", \"-end\", \"-frozen\");\nnewPath = path();\ncount = fprintf('%s %s\\n', oldPath, newPath);",
+            "output": " /contrib:/docs/examples"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `addpath` insist on absolute paths?",
+            "answer": "No. Relative inputs are resolved against the current working directory and stored as absolute paths."
+        },
+        {
+            "question": "What happens with duplicate folders?",
+            "answer": "Existing occurrences are removed before the new ordering is applied, so each folder appears only once."
+        },
+        {
+            "question": "How do I append instead of prepend?",
+            "answer": "Supply `'-end'` as the final argument. Use `'-begin'` to force prepending explicitly."
+        },
+        {
+            "question": "Is `-frozen` supported?",
+            "answer": "The flag is accepted for MATLAB compatibility. RunMat currently treats it as a no-op but plans to integrate tighter tooling once savepath support lands."
+        },
+        {
+            "question": "Can I load `pathdef.m` directly?",
+            "answer": "Not yet. RunMat will add parity support in a future release. For now, evaluate the file manually and pass the resulting character vector to `path`."
+        },
+        {
+            "question": "Do folders need to exist?",
+            "answer": "Yes. RunMat validates that every entry exists and is a directory before updating the search path."
+        },
+        {
+            "question": "Will `addpath` accept GPU strings?",
+            "answer": "Yes. Inputs are gathered automatically, then processed on the CPU."
+        },
+        {
+            "question": "Does `addpath` return the new path?",
+            "answer": "Like MATLAB, `addpath` returns the previous path so it can be restored later with `path(old)`."
+        }
+    ],
+    "links": [
+        {
+            "label": "path",
+            "url": "./path"
+        },
+        {
+            "label": "rmpath",
+            "url": "./rmpath"
+        },
+        {
+            "label": "genpath",
+            "url": "./genpath"
+        },
+        {
+            "label": "which",
+            "url": "./which"
+        },
+        {
+            "label": "exist",
+            "url": "./exist"
+        },
+        {
+            "label": "cd",
+            "url": "./cd"
+        },
+        {
+            "label": "copyfile",
+            "url": "./copyfile"
+        },
+        {
+            "label": "delete",
+            "url": "./delete"
+        },
+        {
+            "label": "dir",
+            "url": "./dir"
+        },
+        {
+            "label": "fullfile",
+            "url": "./fullfile"
+        },
+        {
+            "label": "getenv",
+            "url": "./getenv"
+        },
+        {
+            "label": "ls",
+            "url": "./ls"
+        },
+        {
+            "label": "mkdir",
+            "url": "./mkdir"
+        },
+        {
+            "label": "movefile",
+            "url": "./movefile"
+        },
+        {
+            "label": "pwd",
+            "url": "./pwd"
+        },
+        {
+            "label": "rmdir",
+            "url": "./rmdir"
+        },
+        {
+            "label": "savepath",
+            "url": "./savepath"
+        },
+        {
+            "label": "setenv",
+            "url": "./setenv"
+        },
+        {
+            "label": "tempdir",
+            "url": "./tempdir"
+        },
+        {
+            "label": "tempname",
+            "url": "./tempname"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/io/repl_fs/addpath.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/repl_fs/addpath.rs"
+    },
+    "gpu_residency": "No. `addpath` operates entirely on CPU-side strings. Supplying `gpuArray` text inputs offers no benefit—RunMat gathers them automatically.",
+    "gpu_behavior": [
+        "`addpath` manipulates host-side configuration. If any input value resides on the GPU, RunMat gathers it back to the host before parsing. No acceleration provider hooks or kernels are involved."
+    ],
+    "key": "addpath",
+    "slug": "addpath",
+    "categoryPath": [
+        "io",
+        "repl_fs"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=addpath.js.map

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

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

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

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

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

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

package/dist/generated/builtins/all.js

@@ -0,0 +1,207 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "all",
+    "category": "math/reduction",
+    "keywords": [
+        "all",
+        "logical reduction",
+        "omitnan",
+        "gpu",
+        "vectorization"
+    ],
+    "summary": "Check whether every element of an array slice is nonzero with MATLAB-compatible semantics.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": true,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "RunMat uses provider hooks (`reduce_all_dim`, `reduce_all`) when available; otherwise the runtime gathers to the host and evaluates there."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": true,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::reduction::all::tests",
+        "integration": "builtins::math::reduction::all::tests::all_gpu_provider_roundtrip"
+    },
+    "description": "`all(X)` returns logical `true` when every element of the requested slice of `X` is nonzero. When you omit the dimension, the reduction runs along the first non-singleton axis, mirroring MATLAB.",
+    "behaviors": [
+        "Works with logical, numeric, complex, and character arrays; other types raise a descriptive error.",
+        "Accepts `all(X, dim)` to reduce along a single dimension or `all(X, vecdim)` to collapse multiple axes at once.",
+        "`all(X, 'all')` flattens the entire array into a single logical scalar.",
+        "`all(___, 'omitnan')` ignores `NaN` values (including complex parts) when deciding whether a slice contains nonzero content; empty or all-`NaN` slices evaluate to `true`.",
+        "`all(___, 'includenan')` (default) treats `NaN` as logical `true`, matching MATLAB behaviour.",
+        "Empty dimensions yield logical ones with MATLAB-compatible shapes; empty arrays reduced with `'all'` return `true`.",
+        "Results are always host-resident logical scalars or logical arrays, even when the input tensor lives on the GPU, because the runtime copies the compact output back to the CPU."
+    ],
+    "examples": [
+        {
+            "description": "Checking if every column is nonzero",
+            "input": "A = [1 2 3; 4 5 6];\ncolAllNonZero = all(A)",
+            "output": "colAllNonZero = [1 1 1]"
+        },
+        {
+            "description": "Verifying that each row contains only nonzero values",
+            "input": "B = [1 0 3; 4 5 6; 0 7 8];\nrowAllNonZero = all(B, 2)",
+            "output": "rowAllNonZero = [0; 1; 0]"
+        },
+        {
+            "description": "Collapsing multiple dimensions with `vecdim`",
+            "input": "C = reshape(1:24, [3 4 2]);\nallAlongDims = reshape(all(C > 0, [1 2]), 1, 2)",
+            "output": "1 1"
+        },
+        {
+            "description": "Reducing all elements to a single logical scalar",
+            "input": "D = [2 4; 6 8];\neverythingNonZero = all(D, 'all')",
+            "output": "everythingNonZero = true"
+        },
+        {
+            "description": "Ignoring `NaN` values while testing slices",
+            "input": "E = [NaN 1 2; NaN 0 3];\nwithNaN = all(E);               % returns [1 0 1]\nignoringNaN = all(E, 'omitnan'); % returns [1 0 1]\ndisp(withNaN);\ndisp(ignoringNaN)",
+            "output": "1 0 1\n1 0 1"
+        },
+        {
+            "description": "Evaluating `all` on GPU arrays",
+            "input": "G = gpuArray([1 1 1; 1 1 1]);\ngpuResult = all(G, 2);     % RunMat returns a host logical array\ndisp(gpuResult)",
+            "output": "1\n1"
+        },
+        {
+            "description": "Testing `all` with character arrays",
+            "input": "chars = ['a' 0 'c'];\nallPrintable = all(chars);\ndisp(allPrintable)",
+            "output": "0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I use the `all` function?",
+            "answer": "Use `all` whenever you need to confirm that every element of an array, row, column, or sub-array is nonzero or logical `true`."
+        },
+        {
+            "question": "Does `all` always return logical values?",
+            "answer": "Yes. Results are `logical` scalars or logical arrays even when the computation involves GPU inputs."
+        },
+        {
+            "question": "How do I test a specific dimension?",
+            "answer": "Pass the dimension as the second argument (for example, `all(X, 2)` reduces each row). Provide a vector such as `[1 3]` to collapse multiple axes."
+        },
+        {
+            "question": "What does `all(X, 'all')` compute?",
+            "answer": "It reduces across every dimension of `X` and returns a single logical scalar indicating whether every element of the entire array is nonzero."
+        },
+        {
+            "question": "How are `NaN` values handled?",
+            "answer": "By default they count as nonzero (`'includenan'`). Add `'omitnan'` to ignore them; if every element in a slice is `NaN`, the result becomes `true`."
+        },
+        {
+            "question": "Does `all` work with complex numbers?",
+            "answer": "Yes. Complex values are considered nonzero when either the real or imaginary component is nonzero. Complex values containing `NaN` obey the `'omitnan'`/`'includenan'` rules."
+        },
+        {
+            "question": "Can I apply `all` to character arrays?",
+            "answer": "Yes. Characters compare against their Unicode code points; zero-valued code points are treated as `false`, and everything else is `true`."
+        },
+        {
+            "question": "What happens with empty inputs?",
+            "answer": "Empty reductions follow MATLAB semantics: dimensions of length zero produce logical ones, while `all(X, 'all')` over an empty array evaluates to `true`."
+        },
+        {
+            "question": "How do GPU backends accelerate `all`?",
+            "answer": "Providers may expose specialised AND-reduction kernels (`reduce_all_dim`, `reduce_all`) or use `fused_reduction` to remain on the device. When such hooks are absent, RunMat downloads the small output and computes on the host."
+        }
+    ],
+    "links": [
+        {
+            "label": "any",
+            "url": "./any"
+        },
+        {
+            "label": "prod",
+            "url": "./prod"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "cummax",
+            "url": "./cummax"
+        },
+        {
+            "label": "cummin",
+            "url": "./cummin"
+        },
+        {
+            "label": "cumprod",
+            "url": "./cumprod"
+        },
+        {
+            "label": "cumsum",
+            "url": "./cumsum"
+        },
+        {
+            "label": "diff",
+            "url": "./diff"
+        },
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "median",
+            "url": "./median"
+        },
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "nnz",
+            "url": "./nnz"
+        },
+        {
+            "label": "std",
+            "url": "./std"
+        },
+        {
+            "label": "var",
+            "url": "./var"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/reduction/all.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/all.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` manually. The fusion planner keeps GPU-resident inputs on the device and only gathers the small logical results that `all` produces. If your workload already uses explicit `gpuArray`/`gather` calls for MATLAB compatibility, RunMat honours them and still produces correct logical outputs.",
+    "gpu_behavior": [
+        "RunMat Accelerate keeps inputs resident on the GPU whenever possible. Providers that expose `reduce_all_dim` (and optionally `reduce_all`) perform the AND-reduction on device buffers, and the runtime then downloads the tiny logical result back to the CPU. When those hooks are missing, RunMat gathers the input tensor and evaluates the reduction on the host instead, preserving MATLAB behaviour in all cases."
+    ],
+    "key": "all",
+    "slug": "all",
+    "categoryPath": [
+        "math",
+        "reduction"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=all.js.map

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

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