runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/exist.js

@@ -0,0 +1,213 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "exist",
+    "category": "io/repl_fs",
+    "keywords": [
+        "exist",
+        "file exists",
+        "variable exists",
+        "folder exists",
+        "builtin exists"
+    ],
+    "summary": "Determine whether a variable, file, folder, built-in function, or class exists and return MATLAB-compatible identifiers.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/exist.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs entirely on the CPU. When arguments are gpuArray values RunMat gathers them to the host before evaluating the query."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::io::repl_fs::exist::tests",
+        "integration": "builtins::io::repl_fs::exist::tests::exist_detects_workspace_variables"
+    },
+    "description": "`exist(name)` returns an integer code that identifies which kind of item named `name` is currently available. The codes match MATLAB:\n\n| Code | Meaning                                   | | ---- | ----------------------------------------- | | 0    | Item not found                            | | 1    | Variable in the active workspace          | | 2    | File (including scripts and most data files) | | 3    | MEX-file                                  | | 4    | Simulink® model (`.slx` / `.mdl`)         | | 5    | Built-in MATLAB function                  | | 6    | P-code (`.p` / `.pp`)                     | | 7    | Folder                                    | | 8    | Class definition                          |\n\nPass a second argument to restrict the lookup (for example, `'file'`, `'dir'`, `'builtin'`, `'class'`, `'mex'`, `'pcode'`, `'method'`, or `'handle'`). The builtin mirrors MATLAB semantics for string handling, search order, and numeric return values.",
+    "behaviors": [
+        "Searches follow MATLAB's precedence: variables first, then built-ins, classes, compiled code (MEX/P-code), standard files, and finally folders.",
+        "When you omit the type, `exist` returns the first match respecting this precedence.",
+        "String handling matches MATLAB: `name` and the optional `type` must be character vectors or string scalars. String arrays must contain exactly one element.",
+        "Paths expand `~` to the user's home folder. Relative paths resolve against the current working directory, and RunMat honours `RUNMAT_PATH` / `MATLABPATH` entries when searching for scripts and classes.",
+        "Package-qualified names such as `pkg.func` and `pkg.Class` map to `+pkg` folders automatically. Class queries also recognise `@ClassName` folders and `.m` files that contain `classdef`.",
+        "GPU-resident arguments (for example, `gpuArray(\"script\")`) are gathered automatically, so callers never need to move text back to the CPU manually.",
+        "Unsupported second-argument types surface a MATLAB-compatible error listing the accepted keywords."
+    ],
+    "examples": [
+        {
+            "description": "How to check if a workspace variable exists",
+            "input": "alpha = 3.14;\nstatus = exist(\"alpha\", \"var\")",
+            "output": "status =\n     1"
+        },
+        {
+            "description": "How to determine if a built-in function is available",
+            "input": "code = exist(\"sin\")",
+            "output": "code =\n     5"
+        },
+        {
+            "description": "How to test whether an M-file is on the MATLAB path",
+            "input": "status = exist(\"utilities/process_data\", \"file\")",
+            "output": "status =\n     2"
+        },
+        {
+            "description": "How to verify a folder exists before creating logs",
+            "input": "mkdir(\"logs\");\nstatus = exist(\"logs\", \"dir\")",
+            "output": "status =\n     7"
+        },
+        {
+            "description": "How to detect class definitions in packages",
+            "input": "status = exist(\"pkg.Widget\", \"class\")",
+            "output": "status =\n     8"
+        },
+        {
+            "description": "How to inspect compiled MEX fallbacks",
+            "input": "if exist(\"fastfft\", \"mex\")\n    disp(\"Using compiled fastfft.\");\nelse\n    disp(\"Falling back to MATLAB implementation.\");\nend",
+            "output": "% Prints which implementation will be executed based on the presence of fastfft.mex*."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `exist` support wildcards?",
+            "answer": "No. Strings containing `*` or `?` return `0`, matching MATLAB behaviour."
+        },
+        {
+            "question": "What about Simulink models or Java classes?",
+            "answer": "RunMat reports `4` for `.slx` / `.mdl` files. Java class detection is not implemented yet and currently returns `0`, mirroring MATLAB when Java support is unavailable."
+        },
+        {
+            "question": "How are packages handled?",
+            "answer": "Names like `pkg.func` translate to `+pkg/func.m`. Class queries additionally search `+pkg/@Class` folders."
+        },
+        {
+            "question": "Is the search path configurable?",
+            "answer": "Yes. RunMat honours the current working directory plus any folders listed in `RUNMAT_PATH` or `MATLABPATH` (path separator aware)."
+        },
+        {
+            "question": "What's the search precedence when multiple items share a name?",
+            "answer": "Variables have highest priority, followed by built-ins, classes, compiled code (MEX/P-code), standard files, and folders last—exactly like MATLAB."
+        },
+        {
+            "question": "What happens with unsupported type keywords?",
+            "answer": "The builtin raises `exist: invalid type...` describing the accepted tokens, matching MATLAB's diagnostic."
+        },
+        {
+            "question": "Do handle queries work?",
+            "answer": "When the first argument is a RunMat handle object, `exist(handle, \"handle\")` returns `1`. Numeric graphics handles are not yet supported and return `0`."
+        },
+        {
+            "question": "What does exist do in MATLAB?",
+            "answer": "`exist(name, type)` checks whether a variable, file, folder, or function named `name` exists and returns a numeric code indicating what kind of item was found. Zero means nothing was found."
+        },
+        {
+            "question": "How do I check if a file exists in MATLAB?",
+            "answer": "Use `exist('filename.m', 'file')`. It returns `2` if the file is found on the MATLAB path, or `0` if not found. In RunMat, the same syntax works."
+        },
+        {
+            "question": "What are the return codes for exist in MATLAB?",
+            "answer": "`exist` returns `0` (not found), `1` (variable in workspace), `2` (file on path), `3` (MEX file), `4` (Simulink model), `5` (built-in function), `7` (folder), or `8` (Java class). RunMat supports codes 0, 1, 2, 5, and 7."
+        }
+    ],
+    "links": [
+        {
+            "label": "dir",
+            "url": "./dir"
+        },
+        {
+            "label": "ls",
+            "url": "./ls"
+        },
+        {
+            "label": "copyfile",
+            "url": "./copyfile"
+        },
+        {
+            "label": "pwd",
+            "url": "./pwd"
+        },
+        {
+            "label": "addpath",
+            "url": "./addpath"
+        },
+        {
+            "label": "cd",
+            "url": "./cd"
+        },
+        {
+            "label": "delete",
+            "url": "./delete"
+        },
+        {
+            "label": "fullfile",
+            "url": "./fullfile"
+        },
+        {
+            "label": "genpath",
+            "url": "./genpath"
+        },
+        {
+            "label": "getenv",
+            "url": "./getenv"
+        },
+        {
+            "label": "mkdir",
+            "url": "./mkdir"
+        },
+        {
+            "label": "movefile",
+            "url": "./movefile"
+        },
+        {
+            "label": "path",
+            "url": "./path"
+        },
+        {
+            "label": "rmdir",
+            "url": "./rmdir"
+        },
+        {
+            "label": "rmpath",
+            "url": "./rmpath"
+        },
+        {
+            "label": "savepath",
+            "url": "./savepath"
+        },
+        {
+            "label": "setenv",
+            "url": "./setenv"
+        },
+        {
+            "label": "tempdir",
+            "url": "./tempdir"
+        },
+        {
+            "label": "tempname",
+            "url": "./tempname"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/io/repl_fs/exist.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/repl_fs/exist.rs"
+    },
+    "gpu_residency": "No. `exist` gathers any GPU-resident string inputs transparently. The lookup, file system checks, and return value are always host-side operations. Keeping text on the GPU offers no performance benefits, so you can pass regular character vectors or string scalars.",
+    "gpu_behavior": [
+        "The builtin runs entirely on the host CPU. If any argument lives on the GPU, RunMat gathers it to host memory before performing the lookup. Providers do not implement dedicated hooks for `exist`, and the result is always returned as a host-resident double scalar. Documented behaviour is identical regardless of whether acceleration is enabled."
+    ],
+    "key": "exist",
+    "slug": "exist",
+    "categoryPath": [
+        "io",
+        "repl_fs"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=exist.js.map

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

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

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

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

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

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

package/dist/generated/builtins/exp.js

@@ -0,0 +1,232 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "exp",
+    "category": "math/elementwise",
+    "keywords": [
+        "exp",
+        "exponential",
+        "elementwise",
+        "gpu",
+        "complex"
+    ],
+    "summary": "Element-wise exponential of scalars, vectors, matrices, or N-D tensors.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Falls back to the host implementation when the active provider lacks unary_exp."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::elementwise::exp::tests",
+        "integration": "builtins::math::elementwise::exp::tests::exp_gpu_provider_roundtrip"
+    },
+    "description": "`Y = exp(X)` raises *e* to the power of every element in `X`. Results follow MATLAB semantics for scalars, vectors, matrices, logical arrays, character arrays, and complex inputs.",
+    "behaviors": [
+        "`exp(X)` applies the exponential element-by-element with MATLAB broadcasting rules.",
+        "Logical inputs convert to double (`true → 1.0`, `false → 0.0`) before exponentiation.",
+        "Character arrays are treated as their numeric code points and return dense double tensors.",
+        "Complex values follow MATLAB's definition: `exp(a + bi) = exp(a) * (cos(b) + i·sin(b))`.",
+        "Inputs already living on the GPU stay there when the provider implements `unary_exp`; otherwise RunMat gathers the data, computes on the host, and returns the correct residency."
+    ],
+    "examples": [
+        {
+            "description": "Calculate the exponential of a scalar value",
+            "input": "y = exp(1)",
+            "output": "y = 2.7183"
+        },
+        {
+            "description": "Apply the exponential function to a vector of growth rates",
+            "input": "rates = [-1 -0.5 0 0.5 1];\nfactor = exp(rates)",
+            "output": "factor = [0.3679 0.6065 1 1.6487 2.7183]"
+        },
+        {
+            "description": "Exponentiate every element of a matrix",
+            "input": "A = [0 1 2; 3 4 5];\nB = exp(A)",
+            "output": "B = [1.0000 2.7183 7.3891; 20.0855 54.5982 148.4132]"
+        },
+        {
+            "description": "Compute the exponential of complex numbers",
+            "input": "z = [1+2i, -1+pi*i];\nw = exp(z)",
+            "output": "w = [-1.1312 + 2.4717i, -0.3679 + 0.0000i]"
+        },
+        {
+            "description": "Run element-wise exponential on GPU data",
+            "input": "G = gpuArray([0 1; 2 3]);\nout = exp(G);\nresult = gather(out)",
+            "output": "result = [1.0000 2.7183; 7.3891 20.0855]"
+        },
+        {
+            "description": "Convert character codes to exponentials",
+            "input": "C = 'ABC';\nY = exp(C)",
+            "output": "Y = [1.6949e+28 4.6072e+28 1.2524e+29]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I use the `exp` function?",
+            "answer": "Use `exp` whenever you need the natural exponential of a value or array, such as modelling growth, discounting continuous compounding, or preparing inputs for activation functions."
+        },
+        {
+            "question": "Does `exp` preserve tensor shapes?",
+            "answer": "Yes. `exp` returns a tensor with the same shape as the input, applying broadcasting rules where applicable."
+        },
+        {
+            "question": "How are logical arrays handled?",
+            "answer": "Logical arrays convert to doubles before exponentiation, matching MATLAB behavior: `exp([true false])` returns `[e 1]`."
+        },
+        {
+            "question": "What about complex inputs?",
+            "answer": "Complex scalars and tensors use MATLAB's complex exponential formula, producing complex outputs."
+        },
+        {
+            "question": "What happens when the GPU provider lacks `unary_exp`?",
+            "answer": "RunMat automatically gathers the data to the host, computes the result, and returns a dense tensor. Future GPU operations can still fuse because residency metadata is updated accordingly."
+        },
+        {
+            "question": "Can I expect double precision?",
+            "answer": "Yes. RunMat stores dense numeric tensors as double precision (`f64`). Providers may internally use single precision when configured, but results are converted back to double."
+        }
+    ],
+    "links": [
+        {
+            "label": "logspace",
+            "url": "./logspace"
+        },
+        {
+            "label": "abs",
+            "url": "./abs"
+        },
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "angle",
+            "url": "./angle"
+        },
+        {
+            "label": "conj",
+            "url": "./conj"
+        },
+        {
+            "label": "double",
+            "url": "./double"
+        },
+        {
+            "label": "expm1",
+            "url": "./expm1"
+        },
+        {
+            "label": "factorial",
+            "url": "./factorial"
+        },
+        {
+            "label": "gamma",
+            "url": "./gamma"
+        },
+        {
+            "label": "hypot",
+            "url": "./hypot"
+        },
+        {
+            "label": "imag",
+            "url": "./imag"
+        },
+        {
+            "label": "ldivide",
+            "url": "./ldivide"
+        },
+        {
+            "label": "log",
+            "url": "./log"
+        },
+        {
+            "label": "log10",
+            "url": "./log10"
+        },
+        {
+            "label": "log1p",
+            "url": "./log1p"
+        },
+        {
+            "label": "log2",
+            "url": "./log2"
+        },
+        {
+            "label": "minus",
+            "url": "./minus"
+        },
+        {
+            "label": "plus",
+            "url": "./plus"
+        },
+        {
+            "label": "pow2",
+            "url": "./pow2"
+        },
+        {
+            "label": "power",
+            "url": "./power"
+        },
+        {
+            "label": "rdivide",
+            "url": "./rdivide"
+        },
+        {
+            "label": "real",
+            "url": "./real"
+        },
+        {
+            "label": "sign",
+            "url": "./sign"
+        },
+        {
+            "label": "single",
+            "url": "./single"
+        },
+        {
+            "label": "sqrt",
+            "url": "./sqrt"
+        },
+        {
+            "label": "times",
+            "url": "./times"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/elementwise/exp.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/exp.rs"
+    },
+    "gpu_residency": "You typically do **not** need to call `gpuArray` manually in RunMat. The acceleration planner and fusion engine keep tensors on the GPU automatically when profitable. Users can still call `gpuArray` for explicit residency or to mirror MathWorks MATLAB workflows.",
+    "gpu_behavior": [
+        "RunMat Accelerate keeps GPU tensors resident whenever the selected provider implements `unary_exp`. When the hook is missing or returns an error, RunMat automatically gathers the tensor, computes on the CPU, and re-wraps the result, ensuring correctness without surprising users."
+    ],
+    "key": "exp",
+    "slug": "exp",
+    "categoryPath": [
+        "math",
+        "elementwise"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=exp.js.map

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

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

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

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

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

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