runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/ischar.js

@@ -0,0 +1,154 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "ischar",
+    "category": "introspection",
+    "keywords": [
+        "ischar",
+        "character arrays",
+        "type checking",
+        "char",
+        "logical predicate",
+        "gpuArray"
+    ],
+    "summary": "Test whether a value is a MATLAB character array (char vector or char matrix).",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/ischar.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Returns a host logical scalar; GPU inputs are inspected without launching kernels."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::introspection::ischar::tests",
+        "integration": "builtins::introspection::ischar::tests::ischar_gpu_inputs_return_false"
+    },
+    "description": "`tf = ischar(x)` returns logical `true` when `x` is a MATLAB character array (a char row vector or matrix) and logical `false` otherwise. Use it to distinguish traditional char arrays from the newer string type, numeric tensors, cells, or gpuArray values.",
+    "behaviors": [
+        "Character vectors such as `'RunMat'` and char matrices created with `['A'; 'B']` return `true`.",
+        "Empty char arrays (including `''` and `char.empty(...)`) still count as character arrays.",
+        "String scalars, string arrays, cell arrays, numeric values, and logical masks all return `false`.",
+        "gpuArray inputs return `false` unless they are explicitly stored as char arrays (which RunMat does not currently support), matching MATLAB’s behaviour where gpuArray does not host char data.",
+        "The result is always a host logical scalar (`logical(0)` or `logical(1)`), so it can be used in branching, masking, or validation code without additional conversions."
+    ],
+    "examples": [
+        {
+            "description": "Checking if a character vector is a char array",
+            "input": "tf = ischar('RunMat')",
+            "output": "tf = logical(1)"
+        },
+        {
+            "description": "Detecting multi-row char matrices",
+            "input": "letters = ['ab'; 'cd'];\ntf = ischar(letters)",
+            "output": "tf = logical(1)"
+        },
+        {
+            "description": "Distinguishing between char arrays and string scalars",
+            "input": "tf_char = ischar('hello');\ntf_string = ischar(\"hello\")",
+            "output": "tf_char = logical(1)\ntf_string = logical(0)"
+        },
+        {
+            "description": "Recognising that numeric and logical data are not char arrays",
+            "input": "numbers = [1 2 3];\nmask = true(1, 3);\ntf_numbers = ischar(numbers);\ntf_mask = ischar(mask)",
+            "output": "tf_numbers = logical(0)\ntf_mask = logical(0)"
+        },
+        {
+            "description": "Testing gpuArray inputs",
+            "input": "G = gpuArray(ones(2, 2));\ntf_gpu = ischar(G)",
+            "output": "tf_gpu = logical(0)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `ischar` treat empty character arrays as char?",
+            "answer": "Yes. Both `''` and arrays created with `char.empty` return `logical(1)` because they are still character arrays, even when they have zero elements."
+        },
+        {
+            "question": "Why does `ischar` return `false` for string scalars?",
+            "answer": "Strings in MATLAB are a distinct type introduced in R2016b. They are not interchangeable with char arrays, so `ischar(\"text\")` correctly returns `logical(0)`."
+        },
+        {
+            "question": "What about cell arrays of characters?",
+            "answer": "Cell arrays such as `{'a', 'b'}` return `logical(0)` because they are cell containers rather than a single char array. Use `iscellstr` if you need to validate cell-of-char collections."
+        },
+        {
+            "question": "Can gpuArray hold char data in RunMat?",
+            "answer": "Not currently. gpuArray values in RunMat contain numeric or logical tensors, so `ischar` reports `false` for all gpuArray inputs, mirroring MATLAB’s behaviour."
+        },
+        {
+            "question": "How do I convert a string to a char array if `ischar` returns false?",
+            "answer": "Use `char(stringScalar)` or the `convertStringsToChars` utility when you need to operate on char arrays for legacy APIs."
+        },
+        {
+            "question": "Is there any performance cost when checking large arrays?",
+            "answer": "No. `ischar` only inspects the value’s metadata; it does not copy or iterate over the array elements, so the cost is constant regardless of array size."
+        }
+    ],
+    "links": [
+        {
+            "label": "isa",
+            "url": "./isa"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "strcmp",
+            "url": "./strcmp"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "class",
+            "url": "./class"
+        },
+        {
+            "label": "isstring",
+            "url": "./isstring"
+        },
+        {
+            "label": "which",
+            "url": "./which"
+        },
+        {
+            "label": "who",
+            "url": "./who"
+        },
+        {
+            "label": "whos",
+            "url": "./whos"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/introspection/ischar.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/introspection/ischar.rs"
+    },
+    "gpu_residency": "You usually do NOT need to call `gpuArray` yourself in RunMat (unlike MATLAB).\n\nIn RunMat, the fusion planner keeps residency on GPU in branches of fused expressions. As such, calling `ischar` on a gpuArray result preserves the device buffer, and `ischar` answers the query using metadata only.\n\nTo preserve backwards compatibility with MathWorks MATLAB, and for when you want to explicitly bootstrap GPU residency, you can call `gpuArray` explicitly to move data to the GPU if you want to be explicit about the residency.\n\nSince MathWorks MATLAB does not have a fusion planner, and they kept their parallel execution toolbox separate from the core language, as their toolbox is a separate commercial product, MathWorks MATLAB users need to call `gpuArray` to move data to the GPU manually whereas RunMat users can rely on the fusion planner to keep data on the GPU automatically.",
+    "gpu_behavior": [
+        "`ischar` never launches GPU kernels. When you pass a gpuArray value, RunMat inspects the residency metadata and simply reports `false` because device-resident buffers are numeric or logical. This matches MATLAB’s semantics and avoids unnecessary host↔device transfers."
+    ],
+    "key": "ischar",
+    "slug": "ischar",
+    "categoryPath": [
+        "introspection"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=ischar.js.map

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

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

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

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

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

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

@@ -0,0 +1,152 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "isempty",
+    "category": "array/introspection",
+    "keywords": [
+        "isempty",
+        "empty array",
+        "metadata query",
+        "gpu",
+        "logical"
+    ],
+    "summary": "Return true when an array has zero elements, matching MATLAB semantics.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Reads tensor metadata from handles; falls back to gathering only when provider metadata is absent."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::introspection::isempty::tests",
+        "integration": "builtins::array::introspection::isempty::tests::isempty_gpu_tensor_respects_shape"
+    },
+    "description": "`isempty(A)` returns logical `true` when the MATLAB value `A` contains zero elements. It mirrors MATLAB's behaviour across numeric arrays, logical arrays, character arrays, string arrays, cell arrays, structs, GPU tensors, and handle-like values.",
+    "behaviors": [
+        "Arrays are empty when any dimension is zero (`prod(size(A)) == 0`).",
+        "Character arrays report empty when either dimension is zero. String scalars are never empty (`\"\"` is a `1×1` string array whose content may be empty, but it still counts as one element).",
+        "Cell arrays, struct arrays, and tables (future work) follow their MATLAB dimensions; `cell(0, n)` is empty, while `cell(1, 1)` is not.",
+        "Scalars, logical values, numeric scalars, function handles, objects, and handle objects always return `false` because they occupy one element.",
+        "GPU tensors rely on device-provided shape metadata to avoid unnecessary transfers. If metadata is missing, RunMat gathers once to confirm the shape."
+    ],
+    "examples": [
+        {
+            "description": "Checking if a matrix has any elements",
+            "input": "A = zeros(0, 3);\ntf = isempty(A)",
+            "output": "tf = logical(1)"
+        },
+        {
+            "description": "Detecting an empty cell array",
+            "input": "C = cell(0, 4);\ntf = isempty(C)",
+            "output": "tf = logical(1)"
+        },
+        {
+            "description": "Using `isempty` on a GPU-resident tensor",
+            "input": "G = gpuArray(zeros(5, 0));\ntf = isempty(G)",
+            "output": "tf = logical(1)"
+        },
+        {
+            "description": "Distinguishing char arrays from string scalars",
+            "input": "chars = '';\ntf_chars = isempty(chars);\nstr = \"\";\ntf_str = isempty(str)",
+            "output": "tf_chars = logical(1)\ntf_str = logical(0)"
+        },
+        {
+            "description": "Confirming that scalars are never empty",
+            "input": "value = 42;\ntf = isempty(value)",
+            "output": "tf = logical(0)"
+        },
+        {
+            "description": "Inspecting empty string arrays",
+            "input": "S = strings(0, 2);\ntf = isempty(S)",
+            "output": "tf = logical(1)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `isempty` gather GPU data?",
+            "answer": "Only when the provider fails to populate shape metadata on the GPU handle. Otherwise, it answers using the metadata and avoids transfers."
+        },
+        {
+            "question": "Why is `isempty(\"\")` false but `isempty('')` true?",
+            "answer": "String scalars are `1×1` arrays that hold text content, so they are not empty even when the text has length zero. Character arrays store individual characters; the empty char literal `''` has zero columns, so it is empty."
+        },
+        {
+            "question": "How does `isempty` treat structs and objects?",
+            "answer": "Structs follow their array dimensions. A scalar struct (`1×1`) is not empty, while a `0×0` struct array is empty. Value objects and handle objects are always treated as scalar values, so `isempty` returns `false`."
+        },
+        {
+            "question": "Can `isempty` be used inside GPU-fused expressions?",
+            "answer": "Yes. The builtin returns a host logical scalar and does not allocate GPU buffers, so fusion plans remain valid."
+        },
+        {
+            "question": "Does `isempty` look inside cell arrays?",
+            "answer": "No. It only checks the container dimensions. To look at the contents, inspect individual cells."
+        },
+        {
+            "question": "What does `isempty` return for logical or numeric scalars?",
+            "answer": "They behave like any other scalar and return `false`."
+        }
+    ],
+    "links": [
+        {
+            "label": "numel",
+            "url": "./numel"
+        },
+        {
+            "label": "size",
+            "url": "./size"
+        },
+        {
+            "label": "length",
+            "url": "./length"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "ismatrix",
+            "url": "./ismatrix"
+        },
+        {
+            "label": "isscalar",
+            "url": "./isscalar"
+        },
+        {
+            "label": "isvector",
+            "url": "./isvector"
+        },
+        {
+            "label": "ndims",
+            "url": "./ndims"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/introspection/isempty.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/introspection/isempty.rs"
+    },
+    "gpu_behavior": [
+        "`isempty` does not launch GPU kernels. For GPU-resident tensors (`gpuArray` values), RunMat inspects the shape stored in the `GpuTensorHandle`. When the active provider omits that metadata, the runtime downloads the tensor once to maintain MATLAB-compatible results. The builtin always returns a host logical scalar and does not allocate device memory, so it is safe in fused GPU expressions."
+    ],
+    "key": "isempty",
+    "slug": "isempty",
+    "categoryPath": [
+        "array",
+        "introspection"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=isempty.js.map

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

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

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

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

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

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

package/dist/generated/builtins/isequal.js

@@ -0,0 +1,154 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "isequal",
+    "category": "logical/rel",
+    "keywords": [
+        "isequal",
+        "equality",
+        "comparison",
+        "logical",
+        "array comparison"
+    ],
+    "summary": "Test arrays for equality in size, class, and content.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "GPU tensors are gathered to the host before comparison. Future versions may add native GPU comparison paths."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "none"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::logical::rel::isequal::tests",
+        "integration": null
+    },
+    "description": "`isequal` compares two or more arrays and returns `true` (logical 1) if they all have the same size, class, and content, and `false` (logical 0) otherwise. NaN values are NOT considered equal; use `isequaln` to treat NaN values as equal.",
+    "behaviors": [
+        "`isequal(A, B)` compares two values for equality.",
+        "`isequal(A, B, C, ...)` compares all inputs against each other; returns `true` only if all are equal.",
+        "Arrays must have identical shape (size) to be equal.",
+        "Arrays must have matching data types (class) to be equal.",
+        "All corresponding elements must be identical for arrays to be equal.",
+        "NaN values are NOT equal to each other (NaN ~= NaN).",
+        "Empty arrays `[]` are equal to other empty arrays with the same shape.",
+        "Cell arrays are compared element-by-element recursively.",
+        "Structs are compared field-by-field."
+    ],
+    "examples": [
+        {
+            "description": "Comparing two identical scalars",
+            "input": "isequal(5, 5)",
+            "output": "ans = logical\n     1"
+        },
+        {
+            "description": "Comparing two different scalars",
+            "input": "isequal(5, 6)",
+            "output": "ans = logical\n     0"
+        },
+        {
+            "description": "Comparing identical matrices",
+            "input": "A = [1 2; 3 4];\nB = [1 2; 3 4];\nisequal(A, B)",
+            "output": "ans = logical\n     1"
+        },
+        {
+            "description": "Comparing matrices with different shapes",
+            "input": "A = [1 2 3];\nB = [1; 2; 3];\nisequal(A, B)",
+            "output": "ans = logical\n     0"
+        },
+        {
+            "description": "Comparing multiple arrays at once",
+            "input": "isequal([1 2], [1 2], [1 2])",
+            "output": "ans = logical\n     1"
+        },
+        {
+            "description": "NaN values are not equal",
+            "input": "isequal(NaN, NaN)",
+            "output": "ans = logical\n     0"
+        },
+        {
+            "description": "Verifying that every cell starts with `[]`",
+            "input": "C = cell(2, 2);\nisequal(C{1,1}, [], C{2,2}, [])",
+            "output": "ans = logical\n     1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How is `isequal` different from `==`?",
+            "answer": "`isequal` returns a single logical value indicating whether all inputs are completely identical. The `==` operator performs element-wise comparison and returns an array of the same size as the inputs."
+        },
+        {
+            "question": "How does `isequal` handle NaN values?",
+            "answer": "NaN values are NOT considered equal. `isequal(NaN, NaN)` returns `false`. Use `isequaln` if you want NaN values to be treated as equal."
+        },
+        {
+            "question": "Can I compare more than two arrays?",
+            "answer": "Yes. `isequal(A, B, C, ...)` accepts any number of inputs and returns `true` only if all inputs are equal to each other."
+        },
+        {
+            "question": "Are empty arrays equal?",
+            "answer": "Empty arrays with the same shape are equal. For example, `isequal([], [])` returns `true`, and `isequal(zeros(0,3), zeros(0,3))` returns `true`."
+        },
+        {
+            "question": "How are cell arrays compared?",
+            "answer": "Cell arrays are compared element-by-element. Each corresponding pair of cells must contain equal values for the cell arrays to be equal."
+        },
+        {
+            "question": "What happens with different data types?",
+            "answer": "Values of different classes are generally not equal. However, compatible numeric types (like `double` and `single`, or `double` and `logical`) may be compared after appropriate promotion."
+        }
+    ],
+    "links": [
+        {
+            "label": "eq",
+            "url": "./eq"
+        },
+        {
+            "label": "strcmp",
+            "url": "./strcmp"
+        },
+        {
+            "label": "ge",
+            "url": "./ge"
+        },
+        {
+            "label": "gt",
+            "url": "./gt"
+        },
+        {
+            "label": "le",
+            "url": "./le"
+        },
+        {
+            "label": "lt",
+            "url": "./lt"
+        },
+        {
+            "label": "ne",
+            "url": "./ne"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/logical/rel/isequal.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/logical/rel/isequal.rs"
+    },
+    "gpu_residency": "None. `isequal` gathers GPU tensors to the host for comparison. The result is always a host logical scalar.",
+    "gpu_behavior": [
+        "When comparing gpuArray inputs, `isequal` gathers all tensors to the host before performing the comparison. The result is a scalar logical value on the host."
+    ],
+    "key": "isequal",
+    "slug": "isequal",
+    "categoryPath": [
+        "logical",
+        "rel"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=isequal.js.map

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

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

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

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

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

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

package/dist/generated/builtins/isfield.js

@@ -0,0 +1,140 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "isfield",
+    "category": "structs/core",
+    "keywords": [
+        "isfield",
+        "struct",
+        "struct array",
+        "field existence",
+        "metadata"
+    ],
+    "summary": "Test whether a struct or struct array defines specific field names.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Metadata-only; executes entirely on the host. GPU tensors stored inside structs remain resident."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::structs::core::isfield::tests",
+        "integration": "runmat_ignition::functions::struct_isfield_multi_and_fieldnames"
+    },
+    "description": "`tf = isfield(S, name)` returns a logical value that indicates whether the struct `S` defines the field `name`. When `name` is a string array or a cell array of names, `isfield` returns a logical array with the same size, reporting the result for each requested field.",
+    "behaviors": [
+        "Works with scalar structs and struct arrays created with `struct`, `load`, or similar builtins.",
+        "Accepts character vectors, string scalars, string arrays, or cell arrays containing character vectors and/or string scalars for the `name` argument.",
+        "Returns a scalar logical (`true`/`false`) when `name` is a single string or char vector.",
+        "Returns a logical array that matches the size of `name` when it is a string array or cell array.",
+        "If the first argument is not a struct or struct array, the result is `false` (or a logical array of `false` values) without raising an error.",
+        "Empty struct arrays yield `false` for every queried name because they do not carry field metadata once the elements have been removed."
+    ],
+    "examples": [
+        {
+            "description": "Checking whether a struct defines a single field",
+            "input": "s = struct(\"name\", \"Ada\", \"score\", 42);\nhasScore = isfield(s, \"score\")",
+            "output": "hasScore =\n  logical\n   1"
+        },
+        {
+            "description": "Testing multiple field names at once",
+            "input": "s = struct(\"name\", \"Ada\", \"score\", 42);\nnames = {\"name\", \"department\"; \"score\", \"email\"};\nmask = isfield(s, names)",
+            "output": "mask =\n  2×2 logical array\n     1     0\n     1     0"
+        },
+        {
+            "description": "Inspecting a struct array that shares a common schema",
+            "input": "people = struct(\"name\", {\"Ada\", \"Grace\"}, \"id\", {101, 102});\nidxMask = isfield(people, [\"id\", \"department\"])",
+            "output": "idxMask =\n  1×2 logical array\n     1     0"
+        },
+        {
+            "description": "Using `isfield` before accessing optional configuration fields",
+            "input": "cfg = struct(\"mode\", \"fast\");\nif ~isfield(cfg, \"rate\")\n    cfg.rate = 60;\nend"
+        },
+        {
+            "description": "Mixing string scalars and character vectors in a cell array",
+            "input": "opts = struct(\"Solver\", \"cg\", \"MaxIter\", 200);\nqueries = {\"Solver\", \"Tolerances\"; \"MaxIter\", \"History\"};\npresent = isfield(opts, queries)"
+        },
+        {
+            "description": "Behaviour when the input is not a struct",
+            "input": "value = 42;\ntf = isfield(value, \"anything\")",
+            "output": "tf =\n  logical\n   0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What argument types does `isfield` accept for field names?",
+            "answer": "Character vectors, string scalars, string arrays, and cell arrays that contain character vectors or string scalars. Passing other types raises an error."
+        },
+        {
+            "question": "Does `isfield` error when the first input is not a struct?",
+            "answer": "No. It returns `false` (or a logical array of `false`) to mirror MATLAB's behaviour. Use `isstruct` if you need to guard against non-struct inputs before calling `isfield`."
+        },
+        {
+            "question": "How do struct arrays affect the result?",
+            "answer": "Every element of the struct array must contain the queried field. If any element is missing the field, the result is `false` for that name."
+        },
+        {
+            "question": "What happens with empty struct arrays?",
+            "answer": "Empty struct arrays do not retain field metadata in RunMat yet, so `isfield` returns `false` for all queries. This matches MATLAB when the struct has no defined fields."
+        },
+        {
+            "question": "Are field name comparisons case-sensitive?",
+            "answer": "Yes. Field names are compared using exact, case-sensitive matches, just like MATLAB."
+        },
+        {
+            "question": "Does `isfield` gather GPU data?",
+            "answer": "No. The builtin only inspects field metadata and leaves GPU-resident tensors untouched."
+        }
+    ],
+    "links": [
+        {
+            "label": "fieldnames",
+            "url": "./fieldnames"
+        },
+        {
+            "label": "struct",
+            "url": "./struct"
+        },
+        {
+            "label": "getfield",
+            "url": "./getfield"
+        },
+        {
+            "label": "setfield",
+            "url": "./setfield"
+        },
+        {
+            "label": "orderfields",
+            "url": "./orderfields"
+        },
+        {
+            "label": "rmfield",
+            "url": "./rmfield"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/structs/core/isfield.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/structs/core/isfield.rs"
+    },
+    "gpu_residency": "`isfield` is metadata-only. It neither moves nor inspects the contents of GPU tensors that might live inside the struct. You do not need to call `gpuArray` or `gather` to use the builtin; residency is preserved automatically.",
+    "gpu_behavior": [
+        "`isfield` performs metadata checks entirely on the host. It never gathers or copies GPU tensors that may be stored inside the struct; it only inspects the host-side descriptors that record field names. No acceleration provider hooks are required."
+    ],
+    "key": "isfield",
+    "slug": "isfield",
+    "categoryPath": [
+        "structs",
+        "core"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=isfield.js.map