runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/isnan.js

@@ -0,0 +1,171 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "isnan",
+    "category": "logical/tests",
+    "keywords": [
+        "isnan",
+        "nan mask",
+        "numeric predicate",
+        "gpuArray isnan",
+        "MATLAB isnan"
+    ],
+    "summary": "Return a logical mask indicating which elements of the input are NaN.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Runs on the GPU when the provider exposes `logical_isnan`; otherwise data gathers to the host transparently."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::logical::tests::isnan::tests",
+        "integration": "builtins::logical::tests::isnan::tests::isnan_gpu_roundtrip",
+        "gpu": "builtins::logical::tests::isnan::tests::isnan_wgpu_matches_host_path"
+    },
+    "description": "`mask = isnan(x)` returns a logical scalar or array indicating which elements of `x` are IEEE NaN (Not-a-Number) values. 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 `NaN`.",
+        "Complex inputs report `true` when either the real or imaginary component is `NaN`.",
+        "Logical inputs return `false` because logical values are finite by definition.",
+        "Character arrays return logical arrays of zeros (characters map to finite code points).",
+        "String arrays return logical arrays of zeros, mirroring MATLAB's 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_isnan` hook; otherwise the runtime gathers the data back to the host automatically."
+    ],
+    "examples": [
+        {
+            "description": "Check if a scalar is NaN",
+            "input": "result = isnan(NaN)",
+            "output": "result =\n     1"
+        },
+        {
+            "description": "Create a NaN mask for a numeric matrix",
+            "input": "A = [1 NaN 2; 3 4 NaN];\nmask = isnan(A)",
+            "output": "mask =\n  2×3 logical array\n     0     1     0\n     0     0     1"
+        },
+        {
+            "description": "Identify NaNs inside a complex array",
+            "input": "Z = [1+2i NaN+0i 3+NaNi];\nmask = isnan(Z)",
+            "output": "mask =\n  1×3 logical array\n     0     1     1"
+        },
+        {
+            "description": "Use `isnan` with character data",
+            "input": "chars = ['R' 'u' 'n'];\nmask = isnan(chars)",
+            "output": "mask =\n  1×3 logical array\n     0     0     0"
+        },
+        {
+            "description": "Run `isnan` directly on the GPU",
+            "input": "G = gpuArray([1 0/0 3]);\nmask_gpu = isnan(G);\nmask = gather(mask_gpu)",
+            "output": "mask =\n  1×3 logical array\n     0     1     0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `isnan` modify the input array?",
+            "answer": "No. It returns a logical mask and leaves the input unchanged, whether the data lives on the host or the GPU."
+        },
+        {
+            "question": "How does `isnan` treat complex numbers?",
+            "answer": "It returns `true` when either the real or the imaginary component of the element is `NaN`, matching MATLAB semantics."
+        },
+        {
+            "question": "What does `isnan` return for logical inputs?",
+            "answer": "Logical inputs always produce `false` because logical values (0 or 1) are finite."
+        },
+        {
+            "question": "Does `isnan` support string or character arrays?",
+            "answer": "Yes. Character arrays return logical zeros with the same shape. String arrays return logical zeros per element."
+        },
+        {
+            "question": "What happens when `isnan` runs on a gpuArray without provider support?",
+            "answer": "RunMat gathers the data to the host, computes the mask on the CPU, and returns a host logical array. This guarantees that the builtin never fails even when the GPU backend lacks the specialised kernel."
+        },
+        {
+            "question": "Can I fuse `isnan` with other elementwise operations?",
+            "answer": "Yes. The fusion planner treats `isnan` as an elementwise operation, so expressions like `isnan(A ./ B)` remain eligible for GPU fusion when the provider advertises support."
+        },
+        {
+            "question": "Are there performance differences between `isnan` and `isfinite`/`isinf`?",
+            "answer": "Each predicate performs a single elementwise test. Performance is dominated by memory bandwidth; all three functions have comparable cost on both CPU and GPU."
+        },
+        {
+            "question": "How does `isnan` behave on empty arrays?",
+            "answer": "It returns an empty logical array with the same size metadata as the input, matching MATLAB behavior."
+        },
+        {
+            "question": "What does isnan do in MATLAB?",
+            "answer": "`isnan(A)` returns a logical array the same size as `A`, with `true` where elements are `NaN` and `false` elsewhere. It works on real and complex arrays."
+        },
+        {
+            "question": "How do I remove NaN values from an array in MATLAB?",
+            "answer": "Use `A(isnan(A)) = []` to delete NaN elements from a vector, or `A(~isnan(A))` to select only non-NaN values. For matrices, use `any(isnan(A), 2)` to find rows containing NaN."
+        },
+        {
+            "question": "Does isnan support GPU acceleration in RunMat?",
+            "answer": "Yes. `isnan` runs on the GPU with elementwise fusion, meaning it can be combined with other operations without extra memory round-trips."
+        }
+    ],
+    "links": [
+        {
+            "label": "isfinite",
+            "url": "./isfinite"
+        },
+        {
+            "label": "isinf",
+            "url": "./isinf"
+        },
+        {
+            "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/isnan.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/logical/tests/isnan.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, `isnan` looks for the provider hook `logical_isnan`. Providers that implement the hook execute the NaN 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": "isnan",
+    "slug": "isnan",
+    "categoryPath": [
+        "logical",
+        "tests"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=isnan.js.map

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

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

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

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

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

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

package/dist/generated/builtins/isnumeric.js

@@ -0,0 +1,157 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "isnumeric",
+    "category": "logical/tests",
+    "keywords": [
+        "isnumeric",
+        "numeric type",
+        "type predicate",
+        "gpuArray isnumeric",
+        "MATLAB isnumeric"
+    ],
+    "summary": "Return true when a value is stored as numeric data (real or complex).",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Queries device metadata; falls back to runtime residency tracking when provider hooks are absent."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::logical::tests::isnumeric::tests",
+        "integration": "builtins::logical::tests::isnumeric::tests::gpu_numeric_and_logical_handles",
+        "gpu": "builtins::logical::tests::isnumeric::tests::isnumeric_wgpu_handles_respect_metadata"
+    },
+    "description": "`tf = isnumeric(x)` returns a logical scalar that is `true` when `x` stores numeric data and `false` otherwise. Numeric data includes doubles, singles, integers, and complex numbers, as well as dense numeric arrays that live on the CPU or GPU.",
+    "behaviors": [
+        "Every built-in numeric class (`double`, `single`, signed/unsigned integer types) returns `true`, including complex scalars.",
+        "Real and complex numeric arrays return `true` regardless of dimensionality or residency on the CPU or GPU.",
+        "`gpuArray` values rely on provider metadata: numeric handles return `true`, while logical masks constructed on the GPU return `false`.",
+        "Logical values, characters, strings, tables, cell arrays, structs, objects, and function handles return `false`.",
+        "The result is always a logical scalar."
+    ],
+    "examples": [
+        {
+            "description": "Checking if a scalar double is numeric",
+            "input": "tf = isnumeric(42)",
+            "output": "tf =\n     1"
+        },
+        {
+            "description": "Detecting numeric matrices",
+            "input": "A = [1 2 3; 4 5 6];\ntf = isnumeric(A)",
+            "output": "tf =\n     1"
+        },
+        {
+            "description": "Testing complex numbers for numeric storage",
+            "input": "z = 1 + 2i;\ntf = isnumeric(z)",
+            "output": "tf =\n     1"
+        },
+        {
+            "description": "Logical arrays are not numeric",
+            "input": "mask = logical([1 0 1]);\ntf = isnumeric(mask)",
+            "output": "tf =\n     0"
+        },
+        {
+            "description": "Character vectors and strings return false",
+            "input": "chars = ['R' 'u' 'n'];\nname = \"RunMat\";\ntf_chars = isnumeric(chars);\ntf_string = isnumeric(name)",
+            "output": "tf_chars =\n     0\n\ntf_string =\n     0"
+        },
+        {
+            "description": "Evaluating `gpuArray` inputs",
+            "input": "G = gpuArray(rand(4));\nmask = G > 0.5;\ntf_numeric = isnumeric(G);\ntf_mask = isnumeric(mask)",
+            "output": "tf_numeric =\n     1\n\ntf_mask =\n     0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `isnumeric` ever return an array?",
+            "answer": "No. The builtin always returns a logical scalar, even when the input is an array."
+        },
+        {
+            "question": "Are complex tensors considered numeric?",
+            "answer": "Yes. Real and complex tensors both return `true`, matching MATLAB semantics."
+        },
+        {
+            "question": "Does `isnumeric` gather GPU data back to the host?",
+            "answer": "Only when residency metadata is unavailable. Providers that expose type metadata let RunMat answer the query without host↔device transfers."
+        },
+        {
+            "question": "Do logical masks return `true`?",
+            "answer": "No. Logical scalars and logical arrays return `false`. Use `islogical` if you need to detect logical storage explicitly."
+        },
+        {
+            "question": "What about character vectors or string arrays?",
+            "answer": "They return `false`, just like in MATLAB. Characters and strings are text types rather than numeric arrays."
+        },
+        {
+            "question": "Do cell arrays or structs ever count as numeric?",
+            "answer": "No. Containers and objects always return `false`."
+        },
+        {
+            "question": "Is there a difference between CPU and GPU numeric arrays?",
+            "answer": "No. Both host and device numeric arrays return `true`; only logical GPU handles report `false`."
+        }
+    ],
+    "links": [
+        {
+            "label": "islogical",
+            "url": "./islogical"
+        },
+        {
+            "label": "isreal",
+            "url": "./isreal"
+        },
+        {
+            "label": "isfinite",
+            "url": "./isfinite"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "isgpuarray",
+            "url": "./isgpuarray"
+        },
+        {
+            "label": "isinf",
+            "url": "./isinf"
+        },
+        {
+            "label": "isnan",
+            "url": "./isnan"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/logical/tests/isnumeric.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/logical/tests/isnumeric.rs"
+    },
+    "gpu_residency": "You generally do **not** need to call `gpuArray` manually. RunMat's auto-offload planner keeps numeric tensors on the GPU across fused expressions whenever that improves performance. Explicit `gpuArray` and `gather` calls remain available for compatibility with MATLAB scripts that manage residency themselves.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active, `isnumeric` first checks provider metadata via the `logical_islogical` hook to determine whether a `gpuArray` handle was created as a logical mask. Providers that supply the hook can answer the query without copying data back to the host. When the hook is absent, RunMat consults its residency metadata and only gathers the value to host memory when the residency tag is missing, ensuring the builtin always succeeds."
+    ],
+    "key": "isnumeric",
+    "slug": "isnumeric",
+    "categoryPath": [
+        "logical",
+        "tests"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=isnumeric.js.map

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

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

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

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

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

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

package/dist/generated/builtins/isreal.js

@@ -0,0 +1,152 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "isreal",
+    "category": "logical/tests",
+    "keywords": [
+        "isreal",
+        "complex storage",
+        "real array",
+        "gpuArray isreal",
+        "MATLAB isreal"
+    ],
+    "summary": "Return true when a value uses real storage without an imaginary component.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Queries provider metadata via `logical_isreal`; falls back to a host-side check when a backend does not expose the hook."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::logical::tests::isreal::tests",
+        "integration": "builtins::logical::tests::isreal::tests::isreal_gpu_roundtrip"
+    },
+    "description": "`tf = isreal(x)` returns a logical scalar that is `true` when the value `x` is stored without an imaginary component, and `false` otherwise. It mirrors MATLAB's storage-centric definition: any complex storage (even with zero-valued imaginary parts) is reported as not real.",
+    "behaviors": [
+        "Real numeric scalars and dense tensors return `true`.",
+        "Logical arrays, `duration`, `calendarDuration`, and character arrays always return `true`.",
+        "Complex scalars and `ComplexTensor` values return `false`, even when every imaginary component equals zero, because the data uses complex storage.",
+        "`string`, `table`, `cell`, `struct`, `datetime`, `function_handle`, and object values always return `false`, matching MATLAB's documented rules.",
+        "The return value is always a logical scalar; `isreal` does **not** produce per-element masks."
+    ],
+    "examples": [
+        {
+            "description": "Checking if a real-valued matrix is stored as real",
+            "input": "A = [7 3 2; 2 1 12; 52 108 78];\ntf = isreal(A)",
+            "output": "tf =\n     1"
+        },
+        {
+            "description": "Detecting complex entries inside an array",
+            "input": "B = [1 3+4i 2; 2i 1 12];\ntf = isreal(B)",
+            "output": "tf =\n     0"
+        },
+        {
+            "description": "Complex storage with zero-valued imaginary parts still reports false",
+            "input": "C = complex(12);   % Stored as complex double with 0 imaginary part\ntf = isreal(C)",
+            "output": "tf =\n     0"
+        },
+        {
+            "description": "Logical and character data are considered real",
+            "input": "mask = logical([1 0 1]);\nchars = ['R' 'u' 'n'];\ntf_mask = isreal(mask);\ntf_chars = isreal(chars)",
+            "output": "tf_mask =\n     1\n\ntf_chars =\n     1"
+        },
+        {
+            "description": "Strings, cells, and structs are never real",
+            "input": "txt = \"RunMat\";\nvec = {1, 2};\nperson = struct(\"name\", \"Ada\");\ntf_txt = isreal(txt);\ntf_vec = isreal(vec);\ntf_person = isreal(person)",
+            "output": "tf_txt =\n     0\n\ntf_vec =\n     0\n\ntf_person =\n     0"
+        },
+        {
+            "description": "Querying `gpuArray` storage without gathering data",
+            "input": "G = gpuArray(rand(1024, 1024));\ntf_gpu = isreal(G)",
+            "output": "tf_gpu =\n     1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `isreal` inspect each element of the array?",
+            "answer": "No. It is a storage-level predicate. Use `imag(A) == 0` or `A == real(A)` if you need per-element checks."
+        },
+        {
+            "question": "Why does `isreal` return false for `complex(5)` or `1 + 0i`?",
+            "answer": "Those expressions allocate complex storage even though the imaginary part is zero. MATLAB and RunMat both treat that storage as complex, so `isreal` returns `false`."
+        },
+        {
+            "question": "What about logical arrays, durations, or character data?",
+            "answer": "They always return `true` because those types never allocate an imaginary component."
+        },
+        {
+            "question": "Why do strings, cells, structs, or objects return false?",
+            "answer": "MATLAB documents that `isreal` returns `false` for those container and object types. RunMat follows the same rules for compatibility."
+        },
+        {
+            "question": "Will `isreal` trigger GPU computation or kernel launches?",
+            "answer": "No. It is a metadata query. Providers can answer it without dispatching kernels, and the runtime falls back to a single host download only when necessary."
+        },
+        {
+            "question": "How can I check whether each element is real on the GPU?",
+            "answer": "Use elementwise predicates such as `imag`/`real` combined with comparison (`imag(A) == 0`) or express the logic with fused operations. `isreal` is intentionally scalar."
+        }
+    ],
+    "links": [
+        {
+            "label": "isfinite",
+            "url": "./isfinite"
+        },
+        {
+            "label": "isinf",
+            "url": "./isinf"
+        },
+        {
+            "label": "isnan",
+            "url": "./isnan"
+        },
+        {
+            "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/isreal.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/logical/tests/isreal.rs"
+    },
+    "gpu_residency": "Normally you do **not** need to call `gpuArray` explicitly. RunMat's auto-offload planner tracks when tensors already reside on the GPU and keeps them there. `isreal` simply inspects storage metadata and returns a host logical scalar, gathering device data only as a fallback.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active, the runtime asks the registered provider for the `logical_isreal` hook. A provider can answer the query using device metadata without downloading the tensor. If the hook is unavailable, RunMat gathers the value once and performs the storage check on the host, so the builtin always returns a result."
+    ],
+    "key": "isreal",
+    "slug": "isreal",
+    "categoryPath": [
+        "logical",
+        "tests"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=isreal.js.map

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

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

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

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

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

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