runmat 0.3.6 → 0.4.0

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

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

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

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

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

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

package/dist/generated/builtins/isfinite.js

@@ -0,0 +1,150 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "isfinite",
+    "category": "logical/tests",
+    "keywords": [
+        "isfinite",
+        "finite mask",
+        "numeric predicate",
+        "gpuArray isfinite",
+        "MATLAB isfinite"
+    ],
+    "summary": "Return a logical mask indicating which elements of the input are finite.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Runs on the GPU when the provider exposes `logical_isfinite`; otherwise the runtime gathers to the host transparently."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::logical::tests::isfinite::tests",
+        "integration": "builtins::logical::tests::isfinite::tests::isfinite_gpu_roundtrip",
+        "gpu": "builtins::logical::tests::isfinite::tests::isfinite_wgpu_matches_host_path"
+    },
+    "description": "`mask = isfinite(x)` returns a logical scalar or array indicating which elements of `x` are finite (not `NaN`, `+Inf`, or `-Inf`). The output matches MATLAB's semantics for scalars, matrices, higher-dimensional tensors, and `gpuArray` values.",
+    "behaviors": [
+        "Numeric scalars return a logical scalar (`true`/`false`).",
+        "Numeric arrays return a logical array of the same size, with `true` wherever the corresponding element is finite.",
+        "Complex inputs report `true` when both the real and imaginary components are finite.",
+        "Logical inputs return `true` because logical values (0 or 1) are finite by construction.",
+        "Character arrays return logical arrays of ones (characters map to finite Unicode code points).",
+        "String scalars return `false`; string arrays return logical arrays of zeros, mirroring MATLAB behavior.",
+        "When the input is a `gpuArray`, RunMat keeps the computation on the device if the active acceleration provider implements the `logical_isfinite` hook; otherwise the runtime gathers the data back to the host automatically."
+    ],
+    "examples": [
+        {
+            "description": "Check if a scalar is finite",
+            "input": "result = isfinite(42)",
+            "output": "result =\n     1"
+        },
+        {
+            "description": "Create a finite mask for a numeric matrix",
+            "input": "A = [1 NaN; Inf 4];\nmask = isfinite(A)",
+            "output": "mask =\n  2×2 logical array\n     1     0\n     0     1"
+        },
+        {
+            "description": "Identify finite components in a complex array",
+            "input": "Z = [1+2i Inf+0i 3+NaNi];\nmask = isfinite(Z)",
+            "output": "mask =\n  1×3 logical array\n     1     0     0"
+        },
+        {
+            "description": "Apply `isfinite` to character data",
+            "input": "chars = ['R' 'u' 'n'];\nmask = isfinite(chars)",
+            "output": "mask =\n  1×3 logical array\n     1     1     1"
+        },
+        {
+            "description": "Run `isfinite` directly on the GPU",
+            "input": "G = gpuArray([1 -Inf 5]);\nmask_gpu = isfinite(G);\nmask = gather(mask_gpu)",
+            "output": "mask =\n  1×3 logical array\n     1     0     1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `isfinite` treat `NaN` or `Inf` values as finite?",
+            "answer": "No. `isfinite` only returns `true` for values that are neither `NaN` nor infinite. Use `isnan` or `isinf` if you need to distinguish between those cases."
+        },
+        {
+            "question": "What does `isfinite` return for logical inputs?",
+            "answer": "Logical inputs always produce `true` because logical values are limited to 0 or 1, which are finite."
+        },
+        {
+            "question": "How does `isfinite` handle complex numbers?",
+            "answer": "It returns `true` only when both the real and imaginary components of the element are finite, matching MATLAB semantics."
+        },
+        {
+            "question": "What happens with string or character inputs?",
+            "answer": "String scalars return `false`, and string arrays return logical zeros. Character arrays return logical ones because their Unicode code points are finite."
+        },
+        {
+            "question": "Can I fuse `isfinite` with other elementwise operations?",
+            "answer": "Yes. The fusion planner treats `isfinite` as an elementwise operation, so expressions like `isfinite(A ./ B)` remain eligible for GPU fusion when the provider advertises support."
+        },
+        {
+            "question": "Is there a performance difference between `isfinite`, `isnan`, and `isinf`?",
+            "answer": "Each predicate performs a single elementwise test. Performance is dominated by memory bandwidth, so they have comparable cost on both CPU and GPU."
+        }
+    ],
+    "links": [
+        {
+            "label": "isinf",
+            "url": "./isinf"
+        },
+        {
+            "label": "isnan",
+            "url": "./isnan"
+        },
+        {
+            "label": "isreal",
+            "url": "./isreal"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "isgpuarray",
+            "url": "./isgpuarray"
+        },
+        {
+            "label": "islogical",
+            "url": "./islogical"
+        },
+        {
+            "label": "isnumeric",
+            "url": "./isnumeric"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/logical/tests/isfinite.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/logical/tests/isfinite.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. RunMat's auto-offload planner keeps tensors on the GPU across fused expressions when that improves performance. You can still seed residency manually with `gpuArray` for compatibility with MATLAB scripts or when you want fine-grained control over data movement.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active, `isfinite` looks for the provider hook `logical_isfinite`. Providers that implement the hook execute the finite test entirely on the GPU, producing a logical `gpuArray` result without any host transfers. If the hook is absent, RunMat gathers the input tensor back to the CPU, computes the mask on the host, and returns a regular logical array so the builtin always succeeds."
+    ],
+    "key": "isfinite",
+    "slug": "isfinite",
+    "categoryPath": [
+        "logical",
+        "tests"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=isfinite.js.map

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

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

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

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

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

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

package/dist/generated/builtins/isgpuarray.js

@@ -0,0 +1,117 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "isgpuarray",
+    "category": "logical/tests",
+    "keywords": [
+        "isgpuarray",
+        "gpuarray predicate",
+        "gpu type check",
+        "logical test",
+        "MATLAB isgpuarray"
+    ],
+    "summary": "Return true when a value is stored as a gpuArray handle.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Answers using value metadata; no device gather is required."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::logical::tests::isgpuarray::tests"
+    },
+    "description": "`tf = isgpuarray(x)` returns a logical scalar that is `true` when `x` is a gpuArray handle. All other value kinds, including numeric arrays, logical arrays, characters, structs, and objects, return `false`.",
+    "behaviors": [
+        "gpuArray values return `true` without gathering device buffers.",
+        "Numeric, logical, complex, string, character, struct, cell, and object inputs return `false`.",
+        "The result is always a logical scalar."
+    ],
+    "examples": [
+        {
+            "description": "Checking a gpuArray handle",
+            "input": "G = gpuArray(reshape(1:12, [3 4]));\ntf = isgpuarray(G)",
+            "output": "tf =\n     1"
+        },
+        {
+            "description": "Host arrays are not gpuArray values",
+            "input": "A = [1 2 3];\ntf = isgpuarray(A)",
+            "output": "tf =\n     0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `isgpuarray` gather data back to the host?",
+            "answer": "No. It inspects value metadata and returns a logical scalar without triggering a device transfer."
+        },
+        {
+            "question": "What happens if no acceleration provider is registered?",
+            "answer": "`isgpuarray` still reports accurately for values that are already gpuArray handles. If a value is not a gpuArray handle, it returns `false`."
+        }
+    ],
+    "links": [
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "islogical",
+            "url": "./islogical"
+        },
+        {
+            "label": "isa",
+            "url": "./isa"
+        },
+        {
+            "label": "isfinite",
+            "url": "./isfinite"
+        },
+        {
+            "label": "isinf",
+            "url": "./isinf"
+        },
+        {
+            "label": "isnan",
+            "url": "./isnan"
+        },
+        {
+            "label": "isnumeric",
+            "url": "./isnumeric"
+        },
+        {
+            "label": "isreal",
+            "url": "./isreal"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/logical/tests/isgpuarray.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/logical/tests/isgpuarray.rs"
+    },
+    "gpu_residency": "RunMat keeps data on the GPU when a provider is active, and `isgpuarray` lets you verify residency boundaries in MATLAB-style code.",
+    "gpu_behavior": [
+        "The builtin only checks whether the value is a gpuArray handle. It never gathers device buffers or inspects the underlying data contents."
+    ],
+    "key": "isgpuarray",
+    "slug": "isgpuarray",
+    "categoryPath": [
+        "logical",
+        "tests"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=isgpuarray.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"isgpuarray.js","sourceRoot":"","sources":["../../../src/generated/builtins/isgpuarray.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,YAAY;QACZ,oBAAoB;QACpB,gBAAgB;QAChB,cAAc;QACd,mBAAmB;KACpB;IACD,SAAS,EAAE,0DAA0D;IACrE,YAAY,EAAE,EAAE;IAChB,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6DAA6D;KACvE;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,6CAA6C;KACtD;IACD,aAAa,EAAE,gNAAgN;IAC/N,WAAW,EAAE;QACX,iEAAiE;QACjE,+FAA+F;QAC/F,wCAAwC;KACzC;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,4BAA4B;YAC3C,OAAO,EAAE,yDAAyD;YAClE,QAAQ,EAAE,cAAc;SACzB;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,kCAAkC;YAC3C,QAAQ,EAAE,cAAc;SACzB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,mGAAmG;SAC9G;QACD;YACE,UAAU,EAAE,yDAAyD;YACrE,QAAQ,EAAE,8IAA8I;SACzJ;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,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,kEAAkE;QAC3E,KAAK,EAAE,+GAA+G;KACvH;IACD,eAAe,EAAE,qIAAqI;IACtJ,cAAc,EAAE;QACd,2IAA2I;KAC5I;IACD,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,cAAc,EAAE;QACd,SAAS;QACT,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/ishermitian.js

@@ -0,0 +1,159 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "ishermitian",
+    "category": "math/linalg/structure",
+    "keywords": [
+        "ishermitian",
+        "hermitian",
+        "skew-hermitian",
+        "matrix structure",
+        "gpu"
+    ],
+    "summary": "Determine whether a matrix is Hermitian or skew-Hermitian.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Falls back to gathering GPU operands when providers lack a device-side Hermitian predicate."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::linalg::structure::ishermitian::tests",
+        "integration": "builtins::math::linalg::structure::ishermitian::tests::ishermitian_gpu_roundtrip"
+    },
+    "description": "`ishermitian(A)` returns logical `true` when `A` equals its conjugate transpose (`A == A'`). The builtin works with real and complex matrices, logical arrays, and scalars.",
+    "behaviors": [
+        "`ishermitian(A)` tests for Hermitian structure (`A == conj(A').`).",
+        "Pass `'skew'` (or `'skewhermitian'`) to test for skew-Hermitian structure (`A == -conj(A')`).",
+        "Non-square matrices immediately return `false`.",
+        "Diagonal entries must be real for Hermitian matrices and purely imaginary (within tolerance) for skew-Hermitian matrices.",
+        "Logical inputs are promoted to double precision before testing.",
+        "NaN values anywhere in the matrix cause the predicate to return `false`.",
+        "Additional singleton trailing dimensions are allowed; higher-dimensional inputs with more than two non-singleton axes raise an error."
+    ],
+    "examples": [
+        {
+            "description": "How to check if a complex matrix is Hermitian",
+            "input": "A = [2   1-3i; 1+3i   5];\ntf = ishermitian(A)",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "How to determine that a real matrix is Hermitian",
+            "input": "B = [4 2 2; 2 7 3; 2 3 9];\ntf = ishermitian(B)",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "How to spot a matrix that is not Hermitian",
+            "input": "C = [1 2+i; 2-i 1+0.02i];\ntf = ishermitian(C)",
+            "output": "tf = logical\n   0"
+        },
+        {
+            "description": "How to allow numerical noise with a tolerance",
+            "input": "D = [1 1+1e-12; 1-1e-12 1];\ntf = ishermitian(D, 1e-9)",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "How to test for skew-Hermitian structure",
+            "input": "S = [0 2+3i; -2+3i 0];\ntf = ishermitian(S, 'skew')",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "How to inspect a GPU-resident matrix",
+            "input": "G = gpuArray([3 4-2i; 4+2i 6]);\ntf = ishermitian(G)",
+            "output": "tf = logical\n   1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `ishermitian` work with complex matrices?",
+            "answer": "Yes. Off-diagonal elements are compared against the conjugate transpose, and diagonal elements must be real (for Hermitian) or purely imaginary (for skew-Hermitian) within the supplied tolerance."
+        },
+        {
+            "question": "What tolerance values are supported?",
+            "answer": "Pass a finite, non-negative scalar tolerance. The comparison uses the tolerance on the magnitude of the element-wise difference between the matrix and its (signed) conjugate transpose."
+        },
+        {
+            "question": "Can I test for skew-Hermitian matrices?",
+            "answer": "Yes. Provide `'skew'` or `'skewhermitian'` (optionally along with a tolerance) to require `A == -conj(A')`."
+        },
+        {
+            "question": "How are diagonal elements handled?",
+            "answer": "For Hermitian matrices the diagonal entries must be real. For skew-Hermitian matrices the diagonal entries must have zero real part. Imaginary parts are unconstrained in skew mode."
+        },
+        {
+            "question": "How does the builtin treat NaN values?",
+            "answer": "If any element of the matrix is NaN the predicate returns `false`, matching MATLAB behaviour."
+        },
+        {
+            "question": "Do I need to reshape vectors before calling `ishermitian`?",
+            "answer": "Vectors are treated as matrices; column vectors are `n×1` matrices and row vectors are `1×n` matrices. Non-square shapes always return `false`."
+        },
+        {
+            "question": "What happens with empty matrices?",
+            "answer": "Empty square matrices (`0×0`) return `true`, whereas empty rectangular matrices return `false`."
+        },
+        {
+            "question": "Do I need to call `gpuArray` to use `ishermitian` on the GPU?",
+            "answer": "No. RunMat automatically keeps tensors resident on the GPU when it is profitable. Explicit `gpuArray` calls remain available for MATLAB compatibility."
+        }
+    ],
+    "links": [
+        {
+            "label": "issymmetric",
+            "url": "./issymmetric"
+        },
+        {
+            "label": "eig",
+            "url": "./eig"
+        },
+        {
+            "label": "chol",
+            "url": "./chol"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "bandwidth",
+            "url": "./bandwidth"
+        },
+        {
+            "label": "symrcm",
+            "url": "./symrcm"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/linalg/structure/ishermitian.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/linalg/structure/ishermitian.rs"
+    },
+    "gpu_residency": "Manual `gpuArray` / `gather` calls are optional. When a provider implements the Hermitian predicate the computation runs entirely on the GPU and only the boolean result is read back. Otherwise the runtime gathers the tensor automatically and evaluates the predicate on the host.",
+    "gpu_behavior": [
+        "RunMat keeps GPU tensors resident whenever possible. When the active acceleration provider exposes an `ishermitian` predicate hook the comparison runs entirely on the device and only a logical scalar is transferred back. Providers without a dedicated hook fall back to gathering the matrix and running the CPU implementation transparently, so correctness is preserved even without GPU specialisation."
+    ],
+    "key": "ishermitian",
+    "slug": "ishermitian",
+    "categoryPath": [
+        "math",
+        "linalg",
+        "structure"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=ishermitian.js.map

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

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

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

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

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

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

package/dist/generated/builtins/isinf.js

@@ -0,0 +1,151 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "isinf",
+    "category": "logical/tests",
+    "keywords": [
+        "isinf",
+        "infinite mask",
+        "numeric predicate",
+        "gpuArray isinf",
+        "MATLAB isinf"
+    ],
+    "summary": "Return a logical mask indicating which elements of the input are ±Inf.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Runs on the GPU when the provider exposes `logical_isinf`; otherwise the runtime gathers to the host transparently."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::logical::tests::isinf::tests",
+        "integration": "builtins::logical::tests::isinf::tests::isinf_gpu_roundtrip",
+        "gpu": "builtins::logical::tests::isinf::tests::isinf_wgpu_matches_host_path"
+    },
+    "description": "`mask = isinf(x)` returns a logical scalar or array indicating which elements of `x` are positive or negative infinity. The output matches MATLAB's semantics for scalars, matrices, higher-dimensional tensors, strings, logical arrays, and gpuArray values.",
+    "behaviors": [
+        "Numeric scalars return a logical scalar (`true`/`false`).",
+        "Numeric arrays return a logical array of the same size, with `true` wherever the corresponding element is `+Inf` or `-Inf`.",
+        "Complex inputs report `true` when either the real or the imaginary component is infinite.",
+        "Logical inputs return `false` because logical values (0 or 1) are finite by construction.",
+        "Character arrays return logical arrays of zeros (characters map to finite code points).",
+        "String arrays return logical arrays of zeros, mirroring MATLAB behavior.",
+        "`string` scalars (string objects) return a logical scalar `false`.",
+        "When the input is a `gpuArray`, RunMat keeps the computation on the device if the active acceleration provider implements the `logical_isinf` hook; otherwise the runtime gathers the data back to the host automatically."
+    ],
+    "examples": [
+        {
+            "description": "Checking if a scalar is infinite",
+            "input": "result = isinf(1/0)",
+            "output": "result =\n     1"
+        },
+        {
+            "description": "Detecting infinities after division by zero",
+            "input": "A = [1 0; 2 0];\nquot = 1 ./ A;\nmask = isinf(quot)",
+            "output": "mask =\n  2×2 logical array\n     0     1\n     0     1"
+        },
+        {
+            "description": "Flagging infinite components of a complex array",
+            "input": "Z = [Inf+0i 1-Inf*1i 2+3i];\nmask = isinf(Z)",
+            "output": "mask =\n  1×3 logical array\n     1     1     0"
+        },
+        {
+            "description": "Applying `isinf` to character data",
+            "input": "chars = ['R' 'u' 'n'];\nmask = isinf(chars)",
+            "output": "mask =\n  1×3 logical array\n     0     0     0"
+        },
+        {
+            "description": "Running `isinf` directly on the GPU",
+            "input": "G = gpuArray([1 -Inf Inf]);\nmask_gpu = isinf(G);\nmask = gather(mask_gpu)",
+            "output": "mask =\n  1×3 logical array\n     0     1     1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `isinf` treat `NaN` values as infinite?",
+            "answer": "No. `isinf` only reports `true` for IEEE positive or negative infinity. `NaN` values return `false`, so you can combine `isinf` with `isnan` when you need to distinguish between the two."
+        },
+        {
+            "question": "What does `isinf` return for logical inputs?",
+            "answer": "Logical inputs always produce `false` because logical values are limited to 0 or 1, which are finite."
+        },
+        {
+            "question": "How does `isinf` handle complex numbers?",
+            "answer": "It returns `true` when either the real or the imaginary component is infinite, matching MATLAB semantics."
+        },
+        {
+            "question": "Does `isinf` move data between the CPU and GPU?",
+            "answer": "Only when necessary. If the selected provider implements `logical_isinf`, all work stays on the GPU. Otherwise, RunMat gathers the tensor to the host, computes the result, and delivers a logical array."
+        },
+        {
+            "question": "What happens with string or character inputs?",
+            "answer": "String scalars return `false`. Character arrays and string arrays return logical zeros with the same shape as the input."
+        },
+        {
+            "question": "Is there a performance difference between `isinf`, `isnan`, and `isfinite`?",
+            "answer": "Each predicate performs a single elementwise test. Performance is dominated by memory bandwidth, so they have comparable cost on both CPU and GPU."
+        }
+    ],
+    "links": [
+        {
+            "label": "isfinite",
+            "url": "./isfinite"
+        },
+        {
+            "label": "isnan",
+            "url": "./isnan"
+        },
+        {
+            "label": "isreal",
+            "url": "./isreal"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "isgpuarray",
+            "url": "./isgpuarray"
+        },
+        {
+            "label": "islogical",
+            "url": "./islogical"
+        },
+        {
+            "label": "isnumeric",
+            "url": "./isnumeric"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/logical/tests/isinf.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/logical/tests/isinf.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. RunMat's auto-offload planner keeps tensors on the GPU across fused expressions when that improves performance. You can still seed residency manually with `gpuArray` for compatibility with MATLAB scripts or when you want fine-grained control over data movement.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active, `isinf` looks for the provider hook `logical_isinf`. Providers that implement the hook execute the infinity test entirely on the GPU, producing a logical gpuArray result without any host transfers. If the hook is absent, RunMat gathers the input tensor back to the CPU, computes the mask on the host, and returns a regular logical array so the builtin always succeeds."
+    ],
+    "key": "isinf",
+    "slug": "isinf",
+    "categoryPath": [
+        "logical",
+        "tests"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=isinf.js.map

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

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