runmat 0.3.6 → 0.4.0

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

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

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

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

package/dist/generated/builtins/and.js

@@ -0,0 +1,136 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "and",
+    "category": "logical/bit",
+    "keywords": [
+        "logical and",
+        "elementwise and",
+        "boolean and",
+        "MATLAB and",
+        "gpuArray and"
+    ],
+    "summary": "Element-wise logical AND for scalars, arrays, and gpuArray values.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Runs entirely on the GPU when the active provider implements `logical_and`; otherwise inputs gather back to the host automatically."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::logical::bit::and::tests",
+        "integration": "builtins::logical::bit::and::tests::and_gpu_roundtrip",
+        "gpu": "builtins::logical::bit::and::tests::and_wgpu_matches_host_path"
+    },
+    "description": "`and(A, B)` returns the element-wise logical AND of its inputs. Any non-zero value (including `NaN`) evaluates to `true`. The result is a logical scalar when the broadcasted shape has exactly one element, or a logical array otherwise.",
+    "behaviors": [
+        "Accepts logical, numeric, complex, and character arrays; character code points of zero evaluate to `false`.",
+        "Supports MATLAB-style implicit expansion so scalars and singleton dimensions broadcast automatically.",
+        "Propagates empty dimensions: if a broadcasted axis has length `0`, the output is an empty logical array with the same shape.",
+        "Treats `NaN` values as `true`, matching MATLAB's element-wise logical semantics.",
+        "Keeps `gpuArray` inputs on device when the active provider exposes the `logical_and` hook; otherwise the runtime gathers to host transparently."
+    ],
+    "examples": [
+        {
+            "description": "Check if two logical scalars are both true",
+            "input": "result = and(true, false)",
+            "output": "result =\n     0"
+        },
+        {
+            "description": "Combine numeric arrays element-wise with logical AND",
+            "input": "A = [1 0 2 0];\nB = [3 4 0 0];\nC = and(A, B)",
+            "output": "C =\n  1×4 logical array\n     1     0     0     0"
+        },
+        {
+            "description": "Apply logical AND with automatic scalar expansion",
+            "input": "mask = [1; 0; 3; 0];\nflag = and(mask, 5)",
+            "output": "flag =\n  4×1 logical array\n     1\n     0\n     1\n     0"
+        },
+        {
+            "description": "Use logical AND with character arrays",
+            "input": "lhs = ['R' 'u' 'n'];\nrhs = ['R' 'u' 0];\nmatch = and(lhs, rhs)",
+            "output": "match =\n  1×3 logical array\n     1     1     0"
+        },
+        {
+            "description": "Run logical AND directly on the GPU",
+            "input": "G1 = gpuArray([0 2 0 4]);\nG2 = gpuArray([1 0 3 4]);\ndeviceResult = and(G1, G2)\nhostResult = gather(deviceResult)",
+            "output": "deviceResult =\n  1×4 gpuArray logical array\n     0     0     0     1\nhostResult =\n  1×4 logical array\n     0     0     0     1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `and` return logical values?",
+            "answer": "Yes. The result is a logical scalar (`true`/`false`) when the broadcasted shape contains exactly one element; otherwise the function returns a logical array. On the GPU the kernel writes `0.0`/`1.0` elements, and the runtime converts them back to logical values when you gather."
+        },
+        {
+            "question": "How are `NaN` values handled?",
+            "answer": "`NaN` counts as `true`. For example, `and(NaN, 5)` returns `true` because both operands evaluate to non-zero."
+        },
+        {
+            "question": "Is implicit expansion supported?",
+            "answer": "Yes. The inputs follow MATLAB-style implicit expansion rules: dimensions of length `1` broadcast across the other input. Fully incompatible shapes raise a size-mismatch error."
+        },
+        {
+            "question": "Can I use `and` with complex numbers?",
+            "answer": "Yes. Real or complex inputs return `true` when either the real or imaginary component is non-zero. For example, `and(1 + 0i, 0 + 2i)` returns `true`."
+        },
+        {
+            "question": "How does `and` differ from the `&` operator?",
+            "answer": "They share the same element-wise semantics. The functional form is convenient for higher-order code (for example, `arrayfun(@and, ...)`) and for aligning with MATLAB documentation. Use `&&` or `||` for short-circuit scalar logic."
+        },
+        {
+            "question": "What happens when only one input is a `gpuArray`?",
+            "answer": "RunMat promotes the other input to the GPU before dispatch when the auto-offload planner decides it is profitable. If the provider lacks a device implementation, both operands gather to host automatically and the logical result executes on the CPU."
+        }
+    ],
+    "links": [
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "not",
+            "url": "./not"
+        },
+        {
+            "label": "or",
+            "url": "./or"
+        },
+        {
+            "label": "xor",
+            "url": "./xor"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/logical/bit/and.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/logical/bit/and.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. RunMat's native auto-offload logic moves data to the GPU when a fused expression benefits from device execution, and results stay resident until you gather them or the planner needs host access. Call `gpuArray` only when you want to seed residency manually, or when you are porting MATLAB code that already uses explicit device transfers.",
+    "gpu_behavior": [
+        "When both operands reside on the GPU and the active provider implements the `logical_and` hook, RunMat lowers the call into a device kernel that writes `0` or `1` for each element. The fusion planner treats `and` as an element-wise operation, so fused expressions (for example, `and(A > 0, B)`) stay on device without intermediate gathers. If the provider lacks the hook, the runtime gathers the inputs to host memory automatically and executes the CPU implementation instead of failing."
+    ],
+    "key": "and",
+    "slug": "and",
+    "categoryPath": [
+        "logical",
+        "bit"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=and.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"and.js","sourceRoot":"","sources":["../../../src/generated/builtins/and.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,KAAK;IACd,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,aAAa;QACb,iBAAiB;QACjB,aAAa;QACb,YAAY;QACZ,cAAc;KACf;IACD,SAAS,EAAE,oEAAoE;IAC/E,YAAY,EAAE,EAAE;IAChB,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,qIAAqI;KAC/I;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,IAAI;QACnB,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,uDAAuD;QACtE,KAAK,EAAE,gEAAgE;KACxE;IACD,aAAa,EAAE,4OAA4O;IAC3P,WAAW,EAAE;QACX,6GAA6G;QAC7G,uGAAuG;QACvG,8HAA8H;QAC9H,kFAAkF;QAClF,iJAAiJ;KAClJ;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,2BAA2B;YACpC,QAAQ,EAAE,kBAAkB;SAC7B;QACD;YACE,aAAa,EAAE,sDAAsD;YACrE,OAAO,EAAE,+CAA+C;YACxD,QAAQ,EAAE,oDAAoD;SAC/D;QACD;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,2CAA2C;YACpD,QAAQ,EAAE,6DAA6D;SACxE;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,iEAAiE;YAC1E,QAAQ,EAAE,kDAAkD;SAC7D;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,qHAAqH;YAC9H,QAAQ,EAAE,qIAAqI;SAChJ;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,wRAAwR;SACnS;QACD;YACE,UAAU,EAAE,+BAA+B;YAC3C,QAAQ,EAAE,+GAA+G;SAC1H;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,iLAAiL;SAC5L;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,uJAAuJ;SAClK;QACD;YACE,UAAU,EAAE,8CAA8C;YAC1D,QAAQ,EAAE,uOAAuO;SAClP;QACD;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,0PAA0P;SACrQ;KACF;IACD,OAAO,EAAE;QACP;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,IAAI;YACb,KAAK,EAAE,MAAM;SACd;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,yDAAyD;QAClE,KAAK,EAAE,sGAAsG;KAC9G;IACD,eAAe,EAAE,+YAA+Y;IACha,cAAc,EAAE;QACd,yeAAye;KAC1e;IACD,KAAK,EAAE,KAAK;IACZ,MAAM,EAAE,KAAK;IACb,cAAc,EAAE;QACd,SAAS;QACT,KAAK;KACN;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/angle.js

@@ -0,0 +1,230 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "angle",
+    "category": "math/elementwise",
+    "keywords": [
+        "angle",
+        "phase",
+        "argument",
+        "complex",
+        "gpu"
+    ],
+    "summary": "Phase angle of 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_angle or when complex tensors require host-side conversion."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::elementwise::angle::tests",
+        "integration": "builtins::math::elementwise::angle::tests::angle_gpu_provider_roundtrip"
+    },
+    "description": "`angle(x)` returns the phase angle (argument) of each element in `x`. The values are reported in radians and match MATLAB semantics exactly.",
+    "behaviors": [
+        "Complex inputs use `atan2(imag(x), real(x))`, yielding values in `[-π, π]`.",
+        "Real inputs are treated as complex numbers with zero imaginary part. Positive numbers map to `0`, negative numbers map to `π`, and zeros return `0`.",
+        "Logical inputs are promoted to doubles (`true → 1`, `false → 0`) before computing the angle.",
+        "Results are always returned as dense double-precision arrays that preserve the shape of the input.",
+        "Character arrays are interpreted as their numeric code points and produce double arrays of the same size.",
+        "String arrays are unsupported and raise an error, mirroring MATLAB.",
+        "NaN propagation follows IEEE rules: `angle(NaN)` returns `NaN`."
+    ],
+    "examples": [
+        {
+            "description": "Computing the phase of a complex scalar",
+            "input": "z = 3 + 4i;\ntheta = angle(z);\ndisp(theta)",
+            "output": "theta = 0.9273"
+        },
+        {
+            "description": "Extracting angles from a complex vector",
+            "input": "Z = [1+1i, -1+1i, -1-1i, 1-1i];\nphases = angle(Z);\ndisp(phases)",
+            "output": "phases = [0.7854 2.3562 -2.3562 -0.7854]"
+        },
+        {
+            "description": "Determining angles of negative real numbers",
+            "input": "vals = [-2 -1 0 1 2];\nphi = angle(vals);\ndisp(phi)",
+            "output": "phi = [3.1416 3.1416 0 0 0]"
+        },
+        {
+            "description": "Working with GPU-resident arrays",
+            "input": "G = gpuArray([1 -1; -1 1]);\ntheta = angle(gather(G));\ndisp(theta)",
+            "output": "theta =\n\n     0.0000    3.1416\n     3.1416    0.0000"
+        },
+        {
+            "description": "Angles of character code arrays",
+            "input": "C = ['A' 'B'; 'C' 'D'];\ncodes = angle(C);\ndisp(codes)",
+            "output": "codes = [0 0; 0 0]"
+        },
+        {
+            "description": "Angles from logical masks",
+            "input": "mask = logical([0 1; 1 0]);\nphaseMask = angle(mask);\ndisp(phaseMask)",
+            "output": "phaseMask = [0 0; 0 0]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `angle` return values in radians?",
+            "answer": "Yes. Results are reported in radians within the interval `[-π, π]`, matching MATLAB's definition."
+        },
+        {
+            "question": "What happens with zeros?",
+            "answer": "`angle(0)` returns `0`. Complex zeros (`0 + 0i`) also yield `0`."
+        },
+        {
+            "question": "How does `angle` handle NaN inputs?",
+            "answer": "NaNs propagate. `angle(NaN)` evaluates to `NaN`, honoring IEEE arithmetic."
+        },
+        {
+            "question": "Can I pass string arrays to `angle`?",
+            "answer": "No. Like MATLAB, `angle` supports numeric, logical, or character data. Convert strings with `double(string)` if you need numeric codes first."
+        },
+        {
+            "question": "Does `angle` allocate a new array?",
+            "answer": "Yes. The builtin produces a dense double array. Fusion may eliminate the allocation when the surrounding expression can be fused safely."
+        },
+        {
+            "question": "What about GPU execution for complex tensors?",
+            "answer": "Complex runtime tensors currently live on the host. RunMat gathers them automatically, computes the phase angle, and resumes execution. Future providers may add native complex kernels without changing this builtin."
+        },
+        {
+            "question": "Will GPU results match CPU results exactly?",
+            "answer": "Yes for double-precision providers. Single-precision backends may exhibit minor rounding differences, but they remain within typical IEEE tolerance."
+        }
+    ],
+    "links": [
+        {
+            "label": "abs",
+            "url": "./abs"
+        },
+        {
+            "label": "imag",
+            "url": "./imag"
+        },
+        {
+            "label": "real",
+            "url": "./real"
+        },
+        {
+            "label": "sign",
+            "url": "./sign"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "conj",
+            "url": "./conj"
+        },
+        {
+            "label": "double",
+            "url": "./double"
+        },
+        {
+            "label": "exp",
+            "url": "./exp"
+        },
+        {
+            "label": "expm1",
+            "url": "./expm1"
+        },
+        {
+            "label": "factorial",
+            "url": "./factorial"
+        },
+        {
+            "label": "gamma",
+            "url": "./gamma"
+        },
+        {
+            "label": "hypot",
+            "url": "./hypot"
+        },
+        {
+            "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": "single",
+            "url": "./single"
+        },
+        {
+            "label": "sqrt",
+            "url": "./sqrt"
+        },
+        {
+            "label": "times",
+            "url": "./times"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/elementwise/angle.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/angle.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. RunMat's fusion planner and Accelerate layer manage residency automatically, keeping tensors on the GPU whenever device execution is advantageous. Explicit `gpuArray` / `gather` calls remain available for MATLAB compatibility or when you need deterministic residency control.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active, tensors that already reside on the GPU remain on the device. Providers that implement the `unary_angle` hook execute the phase computation directly on the GPU, using the same `atan2(imag, real)` logic as the host path. If the hook is missing—or if the input requires host-side conversions such as complex tensors—RunMat gathers the data, evaluates the phase angle on the CPU, and then honors any downstream fusion or residency decisions automatically."
+    ],
+    "key": "angle",
+    "slug": "angle",
+    "categoryPath": [
+        "math",
+        "elementwise"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=angle.js.map

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

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

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

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

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

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

@@ -0,0 +1,207 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "any",
+    "category": "math/reduction",
+    "keywords": [
+        "any",
+        "logical reduction",
+        "omitnan",
+        "all",
+        "gpu"
+    ],
+    "summary": "Test whether any element of an array is nonzero with MATLAB-compatible options.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": true,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "RunMat uses provider hooks (`reduce_any_dim`, `reduce_any`) 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::any::tests",
+        "integration": "builtins::math::reduction::any::tests::any_gpu_provider_roundtrip"
+    },
+    "description": "`any(X)` returns logical `true` wherever at least one 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 `any(X, dim)` to reduce along a single dimension or `any(X, vecdim)` to collapse multiple axes at once.",
+        "`any(X, 'all')` flattens the entire array into a single logical scalar.",
+        "`any(___, 'omitnan')` ignores `NaN` values (including complex parts) when deciding whether a slice contains nonzero content.",
+        "`any(___, 'includenan')` (default) treats `NaN` as logical `true`, matching MATLAB behaviour.",
+        "Empty dimensions yield logical zeros with MATLAB-compatible shapes; empty arrays reduced with `'all'` return `false`.",
+        "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 any column in a matrix is nonzero",
+            "input": "A = [0 2 0; 0 0 0];\ncolHasData = any(A)",
+            "output": "colHasData = [0 1 0]"
+        },
+        {
+            "description": "Detecting whether any row contains a nonzero entry",
+            "input": "B = [0 4 0; 1 0 0; 0 0 0];\nrowHasData = any(B, 2)",
+            "output": "rowHasData = [1; 1; 0]"
+        },
+        {
+            "description": "Reducing across multiple dimensions with `vecdim`",
+            "input": "C = reshape(1:24, [3 4 2]);\nhasValues = reshape(any(C > 20, [1 2]), 1, 2)",
+            "output": "0 1"
+        },
+        {
+            "description": "Checking all elements with the `'all'` option",
+            "input": "D = [0 0; 0 5];\nanyNonZero = any(D, 'all')",
+            "output": "anyNonZero = true"
+        },
+        {
+            "description": "Ignoring `NaN` values when probing slices",
+            "input": "E = [NaN 0 0; 0 0 0];\nwithNaN = any(E);              % returns [1 0 0]\nignoringNaN = any(E, 'omitnan'); % returns [0 0 0]\ndisp(withNaN);\ndisp(ignoringNaN)",
+            "output": "     1     0     0\n     0     0     0"
+        },
+        {
+            "description": "Running `any` on GPU arrays with automatic fallback",
+            "input": "G = gpuArray([0 1 0; 0 0 0]);\ngpuResult = any(G, 2);\nhostResult = gather(gpuResult);\ndisp(hostResult)",
+            "output": "1\n0"
+        },
+        {
+            "description": "Evaluating `any` on character data",
+            "input": "chars = ['a' 0 'c'];\nhasPrintable = any(chars)",
+            "output": "hasPrintable = 1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I use the `any` function?",
+            "answer": "Use `any` whenever you need to know if any element of an array, row, column, or sub-array is nonzero or logical `true`."
+        },
+        {
+            "question": "Does `any` 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, `any(X, 2)` reduces each row). Provide a vector such as `[1 3]` to collapse multiple axes."
+        },
+        {
+            "question": "What does `any(X, 'all')` compute?",
+            "answer": "It reduces across every dimension of `X` and returns a single logical scalar indicating whether any 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 `false`."
+        },
+        {
+            "question": "Does `any` 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 `any` 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 zeros, while `any(X, 'all')` over an empty array evaluates to `false`."
+        },
+        {
+            "question": "How do GPU backends accelerate `any`?",
+            "answer": "Providers may expose specialised OR-reduction kernels (`reduce_any_dim`, `reduce_any`) 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": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "prod",
+            "url": "./prod"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "all",
+            "url": "./all"
+        },
+        {
+            "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": "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/any.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/any.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 `any` 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_any_dim` (and optionally `reduce_any`) perform the OR-reduction on device buffers, and the runtime then downloads the tiny logical result back to the CPU (every `any` call returns a host logical array). 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": "any",
+    "slug": "any",
+    "categoryPath": [
+        "math",
+        "reduction"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=any.js.map

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

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

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

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

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

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