runmat 0.3.5 → 0.4.0

package/dist/generated/builtins/sprintf.js

@@ -0,0 +1,191 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "sprintf",
+    "category": "strings/core",
+    "keywords": [
+        "sprintf",
+        "format",
+        "printf",
+        "text",
+        "gpu"
+    ],
+    "summary": "Format data into a MATLAB-compatible character vector using printf-style placeholders.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/sprintf.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Formatting executes on the CPU. GPU tensors are gathered via the active provider before substitution."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::core::sprintf::tests",
+        "integration": "builtins::strings::core::sprintf::tests::sprintf_gpu_numeric"
+    },
+    "description": "`sprintf(formatSpec, A1, ..., An)` formats data into a character row vector. It honours MATLAB's printf-style placeholders, including flags (`-`, `+`, space, `0`, `#`), field width, precision, and star (`*`) width/precision arguments. Arrays are processed column-major and the format string repeats automatically until every element has been consumed.",
+    "behaviors": [
+        "`formatSpec` must be text: a character row vector or string scalar. Cell arrays and multi-row character arrays are rejected.",
+        "Arguments can be numeric, logical, strings, character arrays, or cell arrays containing supported scalar types. Numeric inputs accept scalar, vector, or matrix shapes; elements are flattened in column-major order.",
+        "Escape sequences such as `\\n`, `\\t`, `\\r`, `\\f`, `\\b`, `\\a`, `\\v`, octal (`\\123`), and hexadecimal (`\\x7F`) are interpreted before formatting so that `sprintf` can build multi-line text easily.",
+        "Width and precision may be literal digits or drawn from the input list using `*` or `.*`. Star arguments must be scalar numerics and are consumed in order.",
+        "Flags match MATLAB behaviour: `-` left-aligns, `+` forces a sign, space reserves a leading space for positive numbers, `0` enables zero padding, and `#` produces alternate forms for octal, hexadecimal, and binary outputs or preserves the decimal point in fixed-point conversions.",
+        "`%%` emits a literal percent character without consuming arguments.",
+        "Complex inputs are formatted as scalar text (`a+bi`) when used with `%s`; numeric conversions expect real scalars.",
+        "Additional arguments beyond those required by the repeating format string raise an error to match MATLAB diagnostics."
+    ],
+    "examples": [
+        {
+            "description": "Formatting A Scalar Value",
+            "input": "txt = sprintf('Value: %d', 42)",
+            "output": "txt =\n    'Value: 42'"
+        },
+        {
+            "description": "Formatting With Precision And Width",
+            "input": "txt = sprintf('pi ~= %8.4f', pi)",
+            "output": "txt =\n    'pi ~=   3.1416'"
+        },
+        {
+            "description": "Combining Strings And Numbers",
+            "input": "label = sprintf('Trial %02d: %.1f%% complete', 7, 84.95)",
+            "output": "label =\n    'Trial 07: 85.0% complete'"
+        },
+        {
+            "description": "Formatting Vector Inputs",
+            "input": "data = [10 20 30];\ntxt = sprintf('%d ', data)",
+            "output": "txt =\n    '10 20 30 '"
+        },
+        {
+            "description": "Using Star Width/Precision Arguments",
+            "input": "txt = sprintf('%*.*f %*.*f', 4, 2, 15.2, 6, 4, 0.001)",
+            "output": "txt =\n    '15.20  0.0010'"
+        },
+        {
+            "description": "Quoting Text With `%s`",
+            "input": "names = [\"Ada\", \"Grace\"];\ntxt = sprintf('Hello, %s! ', names)",
+            "output": "txt =\n    'Hello, Ada! Hello, Grace! '"
+        },
+        {
+            "description": "Formatting GPU-Resident Data",
+            "input": "G = gpuArray([1.5 2.5 3.5]);\ntxt = sprintf('%.1f;', G)",
+            "output": "txt =\n    '1.5;2.5;3.5;'"
+        },
+        {
+            "description": "Creating Multi-line Text",
+            "input": "message = sprintf('First line\\\\nSecond line\\\\t(indented)')",
+            "output": "message =\n    'First line\nSecond line\t(indented)'"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What happens if there are not enough input values for the format specifiers?",
+            "answer": "RunMat raises `sprintf: not enough input arguments for format specifier` as soon as a placeholder cannot be satisfied. This matches MATLAB's error message."
+        },
+        {
+            "question": "How are additional values treated when the format string contains fewer specifiers?",
+            "answer": "The format string repeats until all array elements are consumed. If the format string consumes no arguments (for example, it contains only literal text) and extra values remain, RunMat raises an error because MATLAB would also treat this as a mismatch."
+        },
+        {
+            "question": "Can I use star (`*`) width or precision arguments with arrays?",
+            "answer": "Yes. Each `*` consumes the next scalar value from the input stream. When you provide arrays for width or precision, elements are read in column-major order the same way data arguments are."
+        },
+        {
+            "question": "Does `sprintf` support complex numbers?",
+            "answer": "Complex values can be formatted with `%s`, which renders MATLAB's canonical `a+bi` text. Numeric conversions require real-valued inputs and raise an error for complex scalars."
+        },
+        {
+            "question": "Are logical values supported?",
+            "answer": "Yes. Logical inputs are promoted to numeric (`1` or `0`) before formatting, so you can combine them with integer or floating-point conversions."
+        },
+        {
+            "question": "Does `sprintf` allocate string scalars?",
+            "answer": "No. `sprintf` always returns a character row vector for MATLAB compatibility. Use `string` or `compose` if you need string scalars or string arrays."
+        },
+        {
+            "question": "Does GPU hardware change formatting behaviour?",
+            "answer": "No. Formatting occurs on the CPU. When GPU tensors appear in the input list, RunMat gathers them to host memory before substitution so the results match MATLAB exactly."
+        },
+        {
+            "question": "How do I emit a literal percent sign?",
+            "answer": "Use `%%` inside the format specification. The formatter converts `%%` into a single `%` without consuming an argument."
+        },
+        {
+            "question": "How are empty inputs handled?",
+            "answer": "If all argument arrays are empty, `sprintf` returns an empty character array (`1×0`). If the format string itself is empty, the result is also empty."
+        },
+        {
+            "question": "What happens with multi-row character arrays?",
+            "answer": "MATLAB requires `formatSpec` to be a row vector. RunMat follows the same rule: multi-row character arrays raise `sprintf: formatSpec must be a character row vector or string scalar`."
+        }
+    ],
+    "links": [
+        {
+            "label": "compose",
+            "url": "./compose"
+        },
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "num2str",
+            "url": "./num2str"
+        },
+        {
+            "label": "strlength",
+            "url": "./strlength"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "str2double",
+            "url": "./str2double"
+        },
+        {
+            "label": "strcmp",
+            "url": "./strcmp"
+        },
+        {
+            "label": "strcmpi",
+            "url": "./strcmpi"
+        },
+        {
+            "label": "string.empty",
+            "url": "./string.empty"
+        },
+        {
+            "label": "strings",
+            "url": "./strings"
+        },
+        {
+            "label": "strncmp",
+            "url": "./strncmp"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/core/sprintf.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/core/sprintf.rs"
+    },
+    "gpu_behavior": [
+        "`sprintf` is a residency sink. When inputs include GPU tensors, RunMat gathers them back to host memory via the active acceleration provider before executing the formatter. Formatting itself runs entirely on the CPU, ensuring consistent behaviour regardless of device availability."
+    ],
+    "key": "sprintf",
+    "slug": "sprintf",
+    "categoryPath": [
+        "strings",
+        "core"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=sprintf.js.map

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

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

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

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

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

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

package/dist/generated/builtins/sqrt.js

@@ -0,0 +1,230 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "sqrt",
+    "category": "math/elementwise",
+    "keywords": [
+        "sqrt",
+        "square root",
+        "elementwise",
+        "gpu",
+        "complex"
+    ],
+    "summary": "Element-wise square root 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 provider lacks unary_sqrt or when the result requires complex values."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::elementwise::sqrt::tests",
+        "integration": "builtins::math::elementwise::sqrt::tests::sqrt_gpu_provider_roundtrip",
+        "gpu": "builtins::math::elementwise::sqrt::tests::sqrt_wgpu_matches_cpu_elementwise"
+    },
+    "description": "`Y = sqrt(X)` computes the principal square root of every element in `X`. Results follow MATLAB semantics for scalars, vectors, matrices, logical arrays, character arrays, and complex inputs. Negative real values automatically promote to complex results so that the output remains exact.",
+    "behaviors": [
+        "`sqrt(X)` applies the operation element-wise with MATLAB broadcasting rules.",
+        "Logical values convert to doubles (`true → 1.0`, `false → 0.0`) before the square root is taken.",
+        "Character arrays are interpreted as their numeric code points and return dense double tensors.",
+        "Negative real inputs yield purely imaginary outputs: `sqrt([-1 4])` returns `[0 + 1i, 2]`.",
+        "Complex inputs follow MATLAB's definition and stay on the principal branch of the complex square root, ensuring continuity across the negative real axis.",
+        "Zeros (including `-0`) remain zero in the output; infinities and NaNs propagate according to IEEE arithmetic."
+    ],
+    "examples": [
+        {
+            "description": "Taking the square root of a positive scalar",
+            "input": "y = sqrt(9)",
+            "output": "y = 3"
+        },
+        {
+            "description": "Square roots of a matrix",
+            "input": "A = [1 4 9; 16 25 36];\nR = sqrt(A)",
+            "output": "R = [1 2 3; 4 5 6]"
+        },
+        {
+            "description": "Square roots of negative inputs produce complex results",
+            "input": "values = [-1 -4 9];\nroots = sqrt(values)",
+            "output": "roots = [0.0000 + 1.0000i, 0.0000 + 2.0000i, 3.0000 + 0.0000i]"
+        },
+        {
+            "description": "Element-wise square root on GPU data",
+            "input": "G = gpuArray([0 1; 4 9]);\nout = sqrt(G);\nresult = gather(out)",
+            "output": "result = [0 1; 2 3]"
+        },
+        {
+            "description": "Square root of complex numbers",
+            "input": "z = [3 + 4i, -1 + 2i];\nw = sqrt(z)",
+            "output": "w = [2 + 1i, 0.7862 + 1.2720i]"
+        },
+        {
+            "description": "Square root of character codes",
+            "input": "C = 'AB';\nnumericRoots = sqrt(C)",
+            "output": "numericRoots = [8.0623 8.2462]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `sqrt` return complex results for negative inputs?",
+            "answer": "Yes. Negative real numbers produce purely imaginary outputs that match MATLAB. Mixed-sign tensors automatically promote to complex tensors."
+        },
+        {
+            "question": "How are logical inputs handled?",
+            "answer": "Logical arrays convert to doubles before the square root is applied, so `sqrt([true false])` returns `[1 0]`."
+        },
+        {
+            "question": "Can the GPU handle negative inputs?",
+            "answer": "Providers currently operate on real buffers. When negative values are present, RunMat gathers the tensor to the host to compute the correct complex result before continuing execution."
+        },
+        {
+            "question": "Does `sqrt` preserve the input shape?",
+            "answer": "Yes. The output has the same shape as the input, with element-wise results."
+        },
+        {
+            "question": "How are NaNs and infinities treated?",
+            "answer": "They follow IEEE rules: `sqrt(NaN)` is `NaN`, `sqrt(Inf)` is `Inf`, and `sqrt(-Inf)` is `0 + Inf·i`."
+        },
+        {
+            "question": "What about complex inputs with small imaginary parts?",
+            "answer": "The implementation uses the principal square root branch and rounds very small real or imaginary components to zero to avoid `-0` artefacts."
+        },
+        {
+            "question": "Will future providers support complex tensors directly?",
+            "answer": "Yes. The current design promotes to host computation when complex results are needed. Future providers may expose complex buffers, and the builtin will automatically benefit from those hooks."
+        }
+    ],
+    "links": [
+        {
+            "label": "abs",
+            "url": "./abs"
+        },
+        {
+            "label": "exp",
+            "url": "./exp"
+        },
+        {
+            "label": "log",
+            "url": "./log"
+        },
+        {
+            "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": "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": "times",
+            "url": "./times"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/elementwise/sqrt.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/sqrt.rs"
+    },
+    "gpu_residency": "You typically do **not** need to call `gpuArray` manually. The acceleration planner and fusion engine keep tensors on the GPU when profitable. If your data contains negative values, RunMat automatically gathers the tensor, produces the complex result on the host, and keeps residency metadata in sync. You can still use `gpuArray`/`gather` to mirror MathWorks MATLAB workflows.",
+    "gpu_behavior": [
+        "RunMat Accelerate keeps tensors on the GPU when the active provider implements both `unary_sqrt` and `reduce_min`, allowing the runtime to prove that every element is non-negative before launching the kernel. When the dataset contains negative values (and therefore requires complex promotion) or when either hook is missing, RunMat gathers the data to the host, computes the MATLAB-compatible result, and updates residency metadata so subsequent operations see the correct value."
+    ],
+    "key": "sqrt",
+    "slug": "sqrt",
+    "categoryPath": [
+        "math",
+        "elementwise"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=sqrt.js.map

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

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

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

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

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

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