runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/sign.js

@@ -0,0 +1,246 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "sign",
+    "category": "math/elementwise",
+    "keywords": [
+        "sign",
+        "signum",
+        "elementwise",
+        "complex",
+        "gpu"
+    ],
+    "summary": "Sign of scalars, vectors, matrices, or N-D tensors with real or complex values.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Falls back to the host when the active provider lacks unary_sign or when complex inputs require host-side normalisation."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::elementwise::sign::tests",
+        "integration": "builtins::math::elementwise::sign::tests::sign_gpu_provider_roundtrip"
+    },
+    "description": "`y = sign(x)` returns the sign of each element of `x`. Real inputs become `-1`, `0`, or `1` depending on their value, while complex inputs are normalised to unit magnitude (`x ./ abs(x)`).",
+    "behaviors": [
+        "Real scalars, vectors, matrices, and higher-dimensional tensors produce `-1`, `0`, or `1` for each element.",
+        "Complex inputs return `x ./ abs(x)`; zero-valued elements remain exactly `0 + 0i`.",
+        "Logical inputs are promoted to doubles before applying the sign function.",
+        "Character arrays are treated as their numeric code points and return doubles of the same shape.",
+        "NaN inputs propagate (`sign(NaN)` is `NaN`), matching MATLAB semantics.",
+        "`Inf` and `-Inf` map to `1` and `-1` respectively; complex numbers with infinite parts normalise accordingly."
+    ],
+    "examples": [
+        {
+            "description": "Determining the sign of a scalar",
+            "input": "result = sign(-42)",
+            "output": "result = -1"
+        },
+        {
+            "description": "Applying `sign` to a vector of mixed values",
+            "input": "v = [-3 -0.0 0 2 5];\ns = sign(v)",
+            "output": "s = [-1 0 0 1 1]"
+        },
+        {
+            "description": "Normalising complex numbers to unit magnitude",
+            "input": "z = [3+4i, -1+1i, 0+0i];\nu = sign(z)",
+            "output": "u = [0.6+0.8i, -0.7071+0.7071i, 0]"
+        },
+        {
+            "description": "Using `sign` with character data",
+            "input": "codes = sign('RunMat')",
+            "output": "codes = [1 1 1 1 1 1]"
+        },
+        {
+            "description": "Working with logical masks",
+            "input": "mask = [false true false; true false true];\nnumeric = sign(mask)",
+            "output": "numeric = [0 1 0; 1 0 1]"
+        },
+        {
+            "description": "Executing `sign` on a GPU-resident tensor",
+            "input": "G = randn(4096, 4096, 'gpuArray');\nS = sign(G)"
+        },
+        {
+            "description": "Handling infinities and NaNs",
+            "input": "values = [Inf, -Inf, NaN, 0];\nout = sign(values)",
+            "output": "out = [1 -1 NaN 0]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `sign` modify NaN values?",
+            "answer": "No. NaN inputs remain NaN, matching IEEE behaviour and MATLAB semantics."
+        },
+        {
+            "question": "How does `sign` handle complex zeros?",
+            "answer": "`0 + 0i` stays `0 + 0i`. Other complex values are scaled to lie on the unit circle (`x ./ abs(x)`)."
+        },
+        {
+            "question": "What happens for infinite complex components?",
+            "answer": "If either component is infinite, RunMat returns a direction vector with unit magnitude (e.g., `1 + 0i` or `±1/√2 ± 1/√2 i`), mirroring MATLAB."
+        },
+        {
+            "question": "Can I call `sign` on string arrays?",
+            "answer": "No. `sign` accepts numeric, logical, or character arrays. Use `double(string)` followed by `sign` if needed."
+        },
+        {
+            "question": "Does `sign` allocate a new array?",
+            "answer": "Yes. The builtin returns a fresh array; downstream fusion may combine operations to reduce allocations."
+        },
+        {
+            "question": "Is GPU execution numerically identical to CPU?",
+            "answer": "Results match within the provider's precision (`single` or `double`). NaN propagation and zero handling remain consistent between CPU and GPU paths."
+        },
+        {
+            "question": "Will `sign` participate in fusion?",
+            "answer": "Yes. The fusion planner can fold `sign` into neighbouring elementwise kernels, keeping data on the GPU when possible."
+        },
+        {
+            "question": "How do I keep results on the GPU?",
+            "answer": "Avoid `gather` unless host data is required. RunMat keeps the outputs of fused expressions device-resident when beneficial."
+        }
+    ],
+    "links": [
+        {
+            "label": "abs",
+            "url": "./abs"
+        },
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "angle",
+            "url": "./angle"
+        },
+        {
+            "label": "conj",
+            "url": "./conj"
+        },
+        {
+            "label": "double",
+            "url": "./double"
+        },
+        {
+            "label": "exp",
+            "url": "./exp"
+        },
+        {
+            "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": "single",
+            "url": "./single"
+        },
+        {
+            "label": "sqrt",
+            "url": "./sqrt"
+        },
+        {
+            "label": "times",
+            "url": "./times"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/elementwise/sign.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/sign.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` manually. RunMat's planner tracks residency and keeps tensors on the GPU whenever it is profitable. Explicit `gpuArray` / `gather` calls remain available for MATLAB compatibility or interoperability with external GPU code.",
+    "gpu_behavior": [
+        "**Hook available:** The sign is evaluated directly on the device with no host transfers.",
+        "**Hook missing or unsupported dtype:** RunMat gathers the tensor, applies the CPU logic (including complex handling), and continues execution transparently."
+    ],
+    "key": "sign",
+    "slug": "sign",
+    "categoryPath": [
+        "math",
+        "elementwise"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=sign.js.map

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

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

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

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

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

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

package/dist/generated/builtins/sin.js

@@ -0,0 +1,179 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "sin",
+    "category": "math/trigonometry",
+    "keywords": [
+        "sin",
+        "sine",
+        "trigonometry",
+        "gpu",
+        "elementwise",
+        "like"
+    ],
+    "summary": "Sine of scalars, vectors, matrices, complex numbers, or character arrays with MATLAB broadcasting and GPU acceleration.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Prefers provider unary_sin hooks; falls back to the host path when a provider is unavailable or cannot service the operand type."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::trigonometry::sin::tests",
+        "integration": "builtins::math::trigonometry::sin::tests::sin_gpu_provider_roundtrip"
+    },
+    "description": "`y = sin(x)` evaluates the sine of each element in `x`, using radians and preserving MATLAB’s column-major layout and broadcasting rules.",
+    "behaviors": [
+        "Operates on scalars, vectors, matrices, and N-D tensors with MATLAB-compatible implicit expansion.",
+        "Logical and integer inputs are promoted to double precision before evaluation so that downstream arithmetic matches MATLAB’s numeric tower.",
+        "Complex values use the analytic extension `sin(a + bi) = sin(a)cosh(b) + i·cos(a)sinh(b)` while propagating `NaN`/`Inf` components independently.",
+        "Character arrays are interpreted through their Unicode code points and return dense double arrays that mirror MATLAB’s behaviour.",
+        "Appending `'like', prototype` mirrors the prototype’s class and residency (host or GPU), re-uploading the result when a device prototype is supplied.",
+        "Empty inputs and singleton dimensions are preserved without introducing extraneous allocations."
+    ],
+    "examples": [
+        {
+            "description": "Computing the sine of a scalar",
+            "input": "y = sin(pi/2)",
+            "output": "y = 1"
+        },
+        {
+            "description": "Computing the sine of a vector",
+            "input": "angles = [0 pi/6 pi/4 pi/3];\nvalues = sin(angles)",
+            "output": "values = [0 0.5 0.7071 0.8660]"
+        },
+        {
+            "description": "Computing the sine of a complex number",
+            "input": "z = sin(1 + 2i)",
+            "output": "z = 3.1658 + 1.9596i"
+        },
+        {
+            "description": "Computing the sine of a matrix on a GPU",
+            "input": "A = reshape(0:5, [3 2]);\nG = gpuArray(A);\nR = sin(G);\nresult = gather(R)",
+            "output": "result =\n         0    0.1411\n    0.8415   -0.7568\n    0.9093   -0.9589"
+        },
+        {
+            "description": "Keeping results on the GPU with a `'like'` prototype",
+            "input": "proto = gpuArray.zeros(1, 1, 'single');\nangles = [0 pi/2];\ndeviceResult = sin(angles, 'like', proto);\ngathered = gather(deviceResult)",
+            "output": "gathered =\n  1x2 single\n     0     1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I use the `sin` function?",
+            "answer": "Whenever you need the elementwise sine for signals, control systems, geometry, or any workflow that depends on periodic functions across scalars, vectors, or higher-dimensional tensors."
+        },
+        {
+            "question": "Does `sin` expect radians or degrees?",
+            "answer": "Radians are required, just like in MATLAB. Use `sin(deg2rad(theta))` or the `sind` builtin if you want to work in degrees."
+        },
+        {
+            "question": "How are logical, integer, or character inputs handled?",
+            "answer": "Logical and integer inputs are promoted to double precision before evaluation, and character arrays are converted to their Unicode code points. The result is always floating-point, matching MATLAB’s behaviour."
+        },
+        {
+            "question": "Can the result stay on the GPU automatically?",
+            "answer": "Yes. If your inputs are already on the GPU—or you pass `'like', gpuArray(…)`—RunMat keeps the output on the device. When a fallback is required, the runtime re-uploads the result so downstream consumers still see a GPU tensor."
+        },
+        {
+            "question": "What happens if the provider does not implement `unary_sin`?",
+            "answer": "RunMat gathers the tensor to the host, computes `sin` with the reference implementation, and applies the requested residency rules (including `'like'` re-uploads) before returning."
+        },
+        {
+            "question": "Does `sin` support complex numbers?",
+            "answer": "Absolutely. Real and imaginary parts are handled according to the analytic extension, and NaNs/Infs propagate component-wise exactly as in MATLAB."
+        },
+        {
+            "question": "Can I use complex prototypes with `'like'`?",
+            "answer": "Not yet. Provide real-valued prototypes (host or GPU) when using `'like'`; complex prototypes raise a descriptive error so you can fall back to the default output rules."
+        }
+    ],
+    "links": [
+        {
+            "label": "cos",
+            "url": "./cos"
+        },
+        {
+            "label": "tan",
+            "url": "./tan"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "acos",
+            "url": "./acos"
+        },
+        {
+            "label": "acosh",
+            "url": "./acosh"
+        },
+        {
+            "label": "asin",
+            "url": "./asin"
+        },
+        {
+            "label": "asinh",
+            "url": "./asinh"
+        },
+        {
+            "label": "atan",
+            "url": "./atan"
+        },
+        {
+            "label": "atan2",
+            "url": "./atan2"
+        },
+        {
+            "label": "atanh",
+            "url": "./atanh"
+        },
+        {
+            "label": "cosh",
+            "url": "./cosh"
+        },
+        {
+            "label": "sinh",
+            "url": "./sinh"
+        },
+        {
+            "label": "tanh",
+            "url": "./tanh"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/trigonometry/sin.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/trigonometry/sin.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. The fusion planner keeps tensors on the GPU whenever the active provider exposes the necessary kernels (such as `unary_sin`). Manual `gpuArray` / `gather` calls remain supported for MATLAB compatibility or when you need to pin residency before interacting with external code.",
+    "gpu_behavior": [
+        "With RunMat Accelerate active, tensors remain on the device and execute through the provider’s `unary_sin` hook (or fused elementwise kernels) without leaving GPU memory.",
+        "If the provider declines the operation—for example, when only CPU precision is available or the operand type is unsupported—RunMat transparently gathers to the host, computes the result, and reapplies the requested residency rules (including `'like'` prototypes).",
+        "Fusion planning keeps neighbouring elementwise operators grouped, reducing host↔device transfers even when an intermediate fallback occurs."
+    ],
+    "key": "sin",
+    "slug": "sin",
+    "categoryPath": [
+        "math",
+        "trigonometry"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=sin.js.map

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

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

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

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

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

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