runmat 0.3.6 → 0.4.1

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

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

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

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

package/dist/generated/builtins/islogical.js

@@ -0,0 +1,153 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "islogical",
+    "category": "logical/tests",
+    "keywords": [
+        "islogical",
+        "logical type",
+        "boolean predicate",
+        "gpuArray logical",
+        "MATLAB islogical"
+    ],
+    "summary": "Return true when a value is stored as MATLAB logical data (scalar or array).",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Checks provider metadata via `logical_islogical`; falls back to host inspection when unavailable."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::logical::tests::islogical::tests",
+        "integration": "builtins::logical::tests::islogical::tests::gpu_handles_use_metadata_when_available",
+        "gpu": "builtins::logical::tests::islogical::tests::islogical_wgpu_elem_eq_sets_metadata"
+    },
+    "description": "`tf = islogical(x)` returns a logical scalar that is `true` when `x` is stored as MATLAB logical data (either a scalar logical or an N-D logical array). All other value kinds, including doubles, integers, characters, structs, and objects, return `false`.",
+    "behaviors": [
+        "Logical scalars (`true`, `false`) return `true`.",
+        "Instances of `logical` arrays return `true`, regardless of dimensionality.",
+        "Numeric, complex, string, character, struct, cell, and object inputs return `false`.",
+        "`gpuArray` values return `true` when their residency metadata marks them as logical; the builtin never gathers device buffers just to answer the query unless metadata is absent.",
+        "The result is always a logical scalar."
+    ],
+    "examples": [
+        {
+            "description": "Checking a logical scalar",
+            "input": "flag = islogical(true)",
+            "output": "flag =\n     1"
+        },
+        {
+            "description": "Verifying a logical array constructed with `logical`",
+            "input": "mask = logical([1 0 1 0]);\nis_mask_logical = islogical(mask)",
+            "output": "is_mask_logical =\n     1"
+        },
+        {
+            "description": "Numeric arrays are not logical",
+            "input": "values = [1 2 3];\nis_logical = islogical(values)",
+            "output": "is_logical =\n     0"
+        },
+        {
+            "description": "Character arrays return false",
+            "input": "chars = ['R' 'u' 'n'];\nis_char_logical = islogical(chars)",
+            "output": "is_char_logical =\n     0"
+        },
+        {
+            "description": "gpuArray comparisons yield logical gpuArrays",
+            "input": "G = gpuArray([1 2 3]);\nmask = G > 1;\ntf = islogical(mask)",
+            "output": "tf =\n     1"
+        },
+        {
+            "description": "Containers and structs are not logical",
+            "input": "items = {true, 1};\nperson = struct(\"name\", \"Ada\");\ntf_cell = islogical(items);\ntf_struct = islogical(person)",
+            "output": "tf_cell =\n     0\n\ntf_struct =\n     0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `islogical` ever return an array?",
+            "answer": "No. The builtin always returns a logical scalar, even when the input is an array."
+        },
+        {
+            "question": "Does `islogical` convert numeric data to logical?",
+            "answer": "No. It only reports whether the storage is already logical. Use the `logical` builtin to convert numeric data explicitly."
+        },
+        {
+            "question": "How does `islogical` behave with `gpuArray` inputs?",
+            "answer": "If the provider exposes `logical_islogical`, the check happens entirely on the GPU. When the hook is absent, RunMat consults residency metadata and, if needed, gathers the value to host memory to inspect its storage kind."
+        },
+        {
+            "question": "Are character or string arrays considered logical?",
+            "answer": "No. Character vectors, string scalars, and string arrays are not logical values and therefore return `false`."
+        },
+        {
+            "question": "Do cell arrays or structs ever count as logical?",
+            "answer": "No. Containers such as cell arrays, structs, tables, and objects always return `false`."
+        },
+        {
+            "question": "Does a logical `gpuArray` gathered back to the host stay logical?",
+            "answer": "Yes. When residency metadata marks the handle as logical, gathering produces a host `logical` array, and `islogical` continues to report `true`."
+        }
+    ],
+    "links": [
+        {
+            "label": "isreal",
+            "url": "./isreal"
+        },
+        {
+            "label": "isfinite",
+            "url": "./isfinite"
+        },
+        {
+            "label": "isnan",
+            "url": "./isnan"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "isgpuarray",
+            "url": "./isgpuarray"
+        },
+        {
+            "label": "isinf",
+            "url": "./isinf"
+        },
+        {
+            "label": "isnumeric",
+            "url": "./isnumeric"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/logical/tests/islogical.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/logical/tests/islogical.rs"
+    },
+    "gpu_residency": "You typically do **not** need to call `gpuArray` manually. RunMat's auto-offload planner keeps logical masks resident on the GPU when downstream expressions benefit from device execution. Explicit `gpuArray` and `gather` calls remain available for compatibility with MATLAB code that manages residency explicitly.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active, `islogical` first asks the registered acceleration provider for the `logical_islogical` hook. Providers that implement the hook respond using device metadata without copying data back to the CPU. If the hook is missing, RunMat consults its own residency metadata and only gathers device buffers as a last resort, ensuring that the builtin always succeeds while minimizing host↔device transfers."
+    ],
+    "key": "islogical",
+    "slug": "islogical",
+    "categoryPath": [
+        "logical",
+        "tests"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=islogical.js.map

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

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

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

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

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

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

package/dist/generated/builtins/ismatrix.js

@@ -0,0 +1,175 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "ismatrix",
+    "category": "array/introspection",
+    "keywords": [
+        "ismatrix",
+        "matrix detection",
+        "metadata query",
+        "logical",
+        "gpu"
+    ],
+    "summary": "Return true when an array has at most two dimensions (m-by-n, including vectors and scalars).",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Inspects tensor metadata directly on GPU handles; falls back to gathering when providers omit shape information."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::introspection::ismatrix::tests",
+        "integration": "builtins::array::introspection::ismatrix::tests::ismatrix_gpu_tensor_uses_handle_shape"
+    },
+    "description": "`ismatrix(A)` returns logical `true` when the input has two dimensions (`m`-by-`n`) and logical `false` otherwise. Scalars and vectors are considered matrices because they occupy a 1-by-1 or 1-by-`n` grid. The builtin mirrors MATLAB semantics across numeric, logical, character, string, cell, struct, and GPU-resident data.",
+    "behaviors": [
+        "Returns `true` for scalars, row vectors, column vectors, and ordinary 2-D matrices.",
+        "Returns `false` for arrays whose rank exceeds two, even if trailing dimensions are singleton (for example, `1×1×1`).",
+        "Empty arrays such as `0×0`, `1×0`, and `0×1` are matrices; higher-rank empties such as `0×0×3` are not.",
+        "Character arrays, string arrays, and cell arrays honor their reported MATLAB dimensions.",
+        "GPU tensors rely on their `GpuTensorHandle` metadata; if a provider omits the shape, RunMat gathers once to inspect it.",
+        "Objects, structs, numeric scalars, and logical scalars behave like their underlying dimensions (`1×1`)."
+    ],
+    "examples": [
+        {
+            "description": "Confirming that a 2-D matrix returns true",
+            "input": "tf = ismatrix([1 2 3; 4 5 6])",
+            "output": "tf = logical(1)"
+        },
+        {
+            "description": "Showing that vectors and scalars count as matrices",
+            "input": "scalar_tf = ismatrix(42);\nrow_tf = ismatrix(1:5);\ncol_tf = ismatrix((1:5)')",
+            "output": "scalar_tf = logical(1)\nrow_tf = logical(1)\ncol_tf = logical(1)"
+        },
+        {
+            "description": "Detecting that higher-dimensional arrays are not matrices",
+            "input": "tf = ismatrix(ones(2,2,3))",
+            "output": "tf = logical(0)"
+        },
+        {
+            "description": "Working with empty arrays",
+            "input": "tf_empty = ismatrix([]);\ntf_row0 = ismatrix(zeros(1,0));\ntf_col0 = ismatrix(zeros(0,1));\ntf_3d_empty = ismatrix(zeros(0,0,3))",
+            "output": "tf_empty = logical(1)\ntf_row0 = logical(1)\ntf_col0 = logical(1)\ntf_3d_empty = logical(0)"
+        },
+        {
+            "description": "Character and string arrays follow their visible dimensions",
+            "input": "tf_char = ismatrix('RunMat');\ntf_string = ismatrix([\"a\",\"b\",\"c\"])",
+            "output": "tf_char = logical(1)\ntf_string = logical(1)"
+        },
+        {
+            "description": "Cell and struct arrays respect their grid layout",
+            "input": "C = {1, 2; 3, 4};\nS = repmat(struct(\"field\", 1), 1, 3, 1);\ntf_cell = ismatrix(C);\ntf_struct = ismatrix(S)",
+            "output": "tf_cell = logical(1)\ntf_struct = logical(0)"
+        },
+        {
+            "description": "Inspecting GPU arrays without explicit gathers",
+            "input": "G = gpuArray(rand(4,4));\ntf_gpu = ismatrix(G)",
+            "output": "tf_gpu = logical(1)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `ismatrix` treat scalars as matrices?",
+            "answer": "Yes. Scalars occupy a 1-by-1 grid, which is a valid two-dimensional matrix in MATLAB semantics."
+        },
+        {
+            "question": "Are vectors considered matrices?",
+            "answer": "Yes. Row and column vectors are 1-by-`N` and `N`-by-1 matrices, so `ismatrix` returns `true`."
+        },
+        {
+            "question": "Do trailing singleton dimensions change the result?",
+            "answer": "Yes. Any array whose rank exceeds two returns `false`, even if the extra dimensions are size one (for example, `1×1×1`)."
+        },
+        {
+            "question": "How are empty arrays handled?",
+            "answer": "Empty arrays with at most two dimensions (such as `0×0`, `1×0`, or `0×1`) return `true`. Higher-rank empties return `false`."
+        },
+        {
+            "question": "What about character, string, or cell arrays?",
+            "answer": "They follow their MATLAB-visible dimensions. A character row vector or 1-by-`N` string array returns `true`, whereas a 1-by-1-by-`N` cell array returns `false`."
+        },
+        {
+            "question": "Will `ismatrix` download GPU data?",
+            "answer": "Only when the active provider fails to populate shape metadata on the `GpuTensorHandle`. Providers that supply the shape avoid any data transfer."
+        },
+        {
+            "question": "Does `ismatrix` participate in fusion or GPU kernels?",
+            "answer": "No. The builtin is a metadata query, always returns a host logical scalar, and never dispatches GPU work."
+        },
+        {
+            "question": "How does `ismatrix` relate to `isvector` and `isscalar`?",
+            "answer": "`isscalar(A)` and `isvector(A)` both imply `ismatrix(A)` because they describe special cases of 2-D arrays. The reverse implication does not necessarily hold."
+        },
+        {
+            "question": "Are objects and structs supported?",
+            "answer": "Yes. Objects and structs are treated as 1-by-1 unless they represent arrays of instances, in which case the reported dimensions determine the answer."
+        },
+        {
+            "question": "Does sparse support change the behaviour?",
+            "answer": "Future sparse tensors will report their dimensions through the same metadata, so the `ismatrix` predicate will remain unchanged."
+        }
+    ],
+    "links": [
+        {
+            "label": "isscalar",
+            "url": "./isscalar"
+        },
+        {
+            "label": "isvector",
+            "url": "./isvector"
+        },
+        {
+            "label": "ndims",
+            "url": "./ndims"
+        },
+        {
+            "label": "size",
+            "url": "./size"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "isempty",
+            "url": "./isempty"
+        },
+        {
+            "label": "length",
+            "url": "./length"
+        },
+        {
+            "label": "numel",
+            "url": "./numel"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/introspection/ismatrix.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/introspection/ismatrix.rs"
+    },
+    "gpu_residency": "You do not need to move data between host and device to call `ismatrix`. The builtin respects existing residency and only downloads data when the provider fails to report shapes. Users who prefer MATLAB-compatible workflows can still call `gpuArray` explicitly, but it is not required for this metadata check.",
+    "gpu_behavior": [
+        "`ismatrix` never launches GPU kernels. For `gpuArray` inputs, the builtin first inspects the shape metadata stored inside the `GpuTensorHandle`. Providers such as the WGPU backend fully populate that metadata so no data transfer occurs. If metadata is absent, RunMat gathers the tensor once to recover its dimensions and then evaluates the predicate on the host. The result is always a host logical scalar, so fusion treats `ismatrix` as a metadata query rather than a device-side operation."
+    ],
+    "key": "ismatrix",
+    "slug": "ismatrix",
+    "categoryPath": [
+        "array",
+        "introspection"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=ismatrix.js.map

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

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

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

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

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

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

package/dist/generated/builtins/ismember.js

@@ -0,0 +1,165 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "ismember",
+    "category": "array/sorting_sets",
+    "keywords": [
+        "ismember",
+        "membership",
+        "set",
+        "rows",
+        "indices",
+        "gpu"
+    ],
+    "summary": "Identify array elements or rows that appear in another array while returning first-match indices.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/ismember.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "When providers lack a dedicated membership hook RunMat gathers GPU tensors and executes the host implementation."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::sorting_sets::ismember::tests",
+        "integration": "builtins::array::sorting_sets::ismember::tests::ismember_gpu_roundtrip"
+    },
+    "description": "`ismember(A, B)` compares the elements (or rows) of `A` against `B` and returns a logical array marking which members of `A` are present in `B`. The optional second output reports the index in `B` of the first matched element. RunMat follows MATLAB semantics for numeric, logical, complex, string, and character arrays.",
+    "behaviors": [
+        "The first output `tf` has the same shape as `A` (or `size(A,1) × 1` when using `'rows'`).",
+        "The optional second output `loc` contains one-based indices into `B`, with `0` for values that are not found.",
+        "Duplicate values in `A` return the index of the first occurrence in `B` every time they match.",
+        "`NaN` values are treated as identical so they match other `NaN` entries in `B`.",
+        "Character arrays follow column-major linear indexing, mirroring MATLAB.",
+        "The `'rows'` option compares complete rows; inputs must agree on the number of columns.",
+        "Legacy flags (`'legacy'`, `'R2012a'`) are deliberately unsupported in RunMat."
+    ],
+    "examples": [
+        {
+            "description": "Checking membership of numeric vectors",
+            "input": "A = [5 7 2 7];\nB = [7 9 5];\n[tf, loc] = ismember(A, B)",
+            "output": "tf =\n     1     1     0     1\nloc =\n     3     1     0     1"
+        },
+        {
+            "description": "Finding row membership in a matrix",
+            "input": "A = [1 2; 3 4; 1 2];\nB = [3 4; 5 6; 1 2];\n[tf, loc] = ismember(A, B, 'rows')",
+            "output": "tf =\n     1\n     1\n     1\nloc =\n     3\n     1\n     3"
+        },
+        {
+            "description": "Locating values and retrieving the index",
+            "input": "values = [10 20 30];\nset = [30 10 40];\n[tf, loc] = ismember(values, set)",
+            "output": "tf =\n     1     0     1\nloc =\n     2     0     1"
+        },
+        {
+            "description": "Testing characters against a set",
+            "input": "chars = ['r','u'; 'n','m'];\nset = ['m','a'; 'r','u'];\n[tf, loc] = ismember(chars, set)",
+            "output": "tf =\n     1     1\n     0     0\nloc =\n     3     1\n     0     0"
+        },
+        {
+            "description": "Working with string arrays",
+            "input": "A = [\"apple\" \"pear\" \"banana\"];\nB = [\"pear\" \"orange\" \"apple\"];\n[tf, loc] = ismember(A, B)",
+            "output": "tf =\n  1×3 logical array\n   1   1   0\nloc =\n  1×3 double\n   3   1   0"
+        },
+        {
+            "description": "Using `ismember` with `gpuArray` inputs",
+            "input": "G = gpuArray([1 4 2 4]);\nH = gpuArray([4 5]);\n[tf, loc] = ismember(G, H)",
+            "output": "tf =\n     0     1     0     1\nloc =\n     0     1     0     1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `ismember` treat `NaN` values as equal?",
+            "answer": "Yes. `NaN` values compare equal for membership tests so every `NaN` in `A` matches any `NaN` in `B`."
+        },
+        {
+            "question": "What happens when an element of `A` is not found in `B`?",
+            "answer": "The corresponding logical entry is `false` and the index output stores `0`, matching MATLAB."
+        },
+        {
+            "question": "Can I use `ismember` with string arrays and character arrays?",
+            "answer": "Yes. String arrays, scalar strings, and character arrays are supported. Mixed string/char inputs should be normalised (for example, convert scalars with `string`)."
+        },
+        {
+            "question": "How does the `'rows'` option change the output shape?",
+            "answer": "`'rows'` compares entire rows and returns outputs of size `size(A,1) × 1`, regardless of how many columns the input matrices contain."
+        },
+        {
+            "question": "Are the legacy flags supported?",
+            "answer": "No. RunMat only implements modern MATLAB semantics. Passing `'legacy'` or `'R2012a'` raises an error, just like other set builtins in RunMat."
+        },
+        {
+            "question": "Will `ismember` run on the GPU automatically?",
+            "answer": "If the active provider advertises an `ismember` hook, the runtime can keep tensors on the device. Otherwise the data is gathered to the host with no behavioural differences."
+        }
+    ],
+    "links": [
+        {
+            "label": "unique",
+            "url": "./unique"
+        },
+        {
+            "label": "intersect",
+            "url": "./intersect"
+        },
+        {
+            "label": "setdiff",
+            "url": "./setdiff"
+        },
+        {
+            "label": "union",
+            "url": "./union"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "argsort",
+            "url": "./argsort"
+        },
+        {
+            "label": "issorted",
+            "url": "./issorted"
+        },
+        {
+            "label": "sort",
+            "url": "./sort"
+        },
+        {
+            "label": "sortrows",
+            "url": "./sortrows"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/sorting_sets/ismember.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/sorting_sets/ismember.rs"
+    },
+    "gpu_residency": "Most code does not need to call `gpuArray` explicitly. The native auto-offload planner keeps track of residency and recognises that `ismember` is a sink: the operation produces logical outputs and one-based indices that currently live on the host. If an acceleration provider exposes a full `ismember` hook in the future, the planner can keep data on the device automatically. Until then, manual `gpuArray` / `gather` calls only serve to mirror MATLAB workflows; RunMat already performs the necessary transfers when it detects that tensors reside on the GPU.",
+    "gpu_behavior": [
+        "When either input is a GPU tensor, RunMat first checks whether the active acceleration provider exposes a custom `ismember` hook. Until providers implement that hook, the runtime transparently gathers GPU operands to host memory, performs the membership lookup using the CPU implementation, and returns host-resident outputs so results exactly match MATLAB."
+    ],
+    "key": "ismember",
+    "slug": "ismember",
+    "categoryPath": [
+        "array",
+        "sorting_sets"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=ismember.js.map

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

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

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

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

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

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