runmat 0.3.5 → 0.4.0

package/dist/generated/builtins/meshgrid.js

@@ -0,0 +1,206 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "meshgrid",
+    "category": "array/creation",
+    "keywords": [
+        "meshgrid",
+        "grid",
+        "surface",
+        "gpu",
+        "like",
+        "3d"
+    ],
+    "summary": "Generate MATLAB mesh grids for 2-D and 3-D coordinate vectors with optional GPU residency.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "RunMat materialises grids on the host and uploads them when GPU residency is requested. Providers may supply dedicated meshgrid hooks to avoid the round-trip."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::creation::meshgrid::tests",
+        "integration": "builtins::array::creation::meshgrid::tests::meshgrid_gpu_inputs_roundtrip"
+    },
+    "description": "`meshgrid` turns one-, two-, or three-dimensional vectors into coordinate arrays that span a rectangular grid, mirroring MathWorks MATLAB behaviour exactly. The first output replicates the `x` vector across rows, the second replicates the `y` vector across columns, and the optional third output expands a `z` vector across pages for volumetric grids.",
+    "behaviors": [
+        "`meshgrid(x)` is shorthand for `[X, Y] = meshgrid(x, x)`. It produces square 2-D grids.",
+        "`meshgrid(x, y)` yields `X` of size `length(y) × length(x)` with rows copied from `x`, and `Y` of the same size with columns copied from `y`.",
+        "`meshgrid(x, y, z)` returns three outputs sized `length(y) × length(x) × length(z)`, enabling 3-D volume visualisation.",
+        "Input vectors may be row or column vectors (or even scalars). Empty vectors propagate to empty grids of matching shape.",
+        "Complex inputs produce complex grids where each output shares the input’s complex values.",
+        "Supplying GPU vectors (or a `'like', gpuArray(...)` prototype) keeps the outputs on the GPU when an acceleration provider is active. Without provider support, RunMat gathers inputs, materialises the grid on the host, and uploads the result transparently.",
+        "`'like', prototype` matches both the residency (host or GPU) and numeric class (real or complex) of the prototype. Integer prototypes are promoted to double precision, consistent with MATLAB."
+    ],
+    "examples": [
+        {
+            "description": "Generating a square 2-D grid from one vector",
+            "input": "x = -2:2;\n[X, Y] = meshgrid(x)",
+            "output": "X =\n    -2    -1     0     1     2\n    -2    -1     0     1     2\n    -2    -1     0     1     2\n    -2    -1     0     1     2\n    -2    -1     0     1     2"
+        },
+        {
+            "description": "Building a rectangular grid from two different vectors",
+            "input": "x = [0 0.5 1.0];\ny = [10 20];\n[X, Y] = meshgrid(x, y)",
+            "output": "X =\n         0    0.5000    1.0000\n         0    0.5000    1.0000\n\nY =\n    10    10    10\n    20    20    20"
+        },
+        {
+            "description": "Creating a volumetric grid for 3-D plotting",
+            "input": "u = -1:1;\nv = 2:4;\nw = linspace(0, 1, 5);\n[U, V, W] = meshgrid(u, v, w);\nsize(U)",
+            "output": "ans =\n     3     3     5"
+        },
+        {
+            "description": "Matching an existing GPU prototype",
+            "input": "gx = gpuArray(single(linspace(-pi, pi, 4)));\ngy = gpuArray(single([-1 0 1]));\n[Xg, Yg] = meshgrid(gx, gy)"
+        },
+        {
+            "description": "Using `'like'` to copy residency from another array",
+            "input": "proto = gpuArray.zeros(1, 1, 'double');\nangles = linspace(0, 2*pi, 8);\nradius = [0 1 2];\n[X, Y] = meshgrid(angles, radius, 'like', proto)"
+        },
+        {
+            "description": "Complex inputs produce complex grids automatically",
+            "input": "z = [1+1i, 2+4i];\n[Zx, Zy] = meshgrid(z)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How many inputs can `meshgrid` accept?",
+            "answer": "One, two, or three numeric vectors. Use three inputs when you need volumetric (3-D) grids."
+        },
+        {
+            "question": "Can I request three outputs with only one or two inputs?",
+            "answer": "No. RunMat follows MATLAB and requires three input vectors when three outputs are requested."
+        },
+        {
+            "question": "Do row or column vectors behave differently?",
+            "answer": "No. Any vector shape (row, column, or scalar) is accepted. RunMat treats the linearised data identically and replicates it along the appropriate axes."
+        },
+        {
+            "question": "What happens with empty vectors?",
+            "answer": "Empty inputs propagate to empty outputs. For example, `meshgrid([], 1:3)` returns `0×3` grids for both outputs."
+        },
+        {
+            "question": "Can I use integer vectors?",
+            "answer": "Yes. Inputs are promoted to double precision internally so the outputs represent the exact same values as MATLAB."
+        },
+        {
+            "question": "Does `meshgrid` support complex numbers?",
+            "answer": "Absolutely. Any imaginary components propagate into the outputs. Complex grids currently stay on the host even if GPU residency is requested."
+        },
+        {
+            "question": "What does `'like'` do?",
+            "answer": "It matches the numeric class and residency (host or GPU) of the prototype array. Supply a `gpuArray` prototype to keep the resulting grids on the GPU."
+        },
+        {
+            "question": "How can providers avoid the host fall-back?",
+            "answer": "Implement the `meshgrid` custom hook in the acceleration provider. RunMat will automatically dispatch to it once available."
+        },
+        {
+            "question": "Is the output always dense?",
+            "answer": "Yes. `meshgrid` produces dense arrays. Use `ndgrid` when you need permuted axes or higher-dimensional grids beyond three inputs."
+        },
+        {
+            "question": "What error do I get if I omit all inputs?",
+            "answer": "RunMat raises the MATLAB-compatible error `meshgrid: at least one input vector is required`."
+        }
+    ],
+    "links": [
+        {
+            "label": "linspace",
+            "url": "./linspace"
+        },
+        {
+            "label": "zeros",
+            "url": "./zeros"
+        },
+        {
+            "label": "ones",
+            "url": "./ones"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "colon",
+            "url": "./colon"
+        },
+        {
+            "label": "eye",
+            "url": "./eye"
+        },
+        {
+            "label": "false",
+            "url": "./false"
+        },
+        {
+            "label": "fill",
+            "url": "./fill"
+        },
+        {
+            "label": "logspace",
+            "url": "./logspace"
+        },
+        {
+            "label": "magic",
+            "url": "./magic"
+        },
+        {
+            "label": "rand",
+            "url": "./rand"
+        },
+        {
+            "label": "randi",
+            "url": "./randi"
+        },
+        {
+            "label": "randn",
+            "url": "./randn"
+        },
+        {
+            "label": "randperm",
+            "url": "./randperm"
+        },
+        {
+            "label": "range",
+            "url": "./range"
+        },
+        {
+            "label": "true",
+            "url": "./true"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/creation/meshgrid.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/creation/meshgrid.rs"
+    },
+    "gpu_residency": "You usually do **not** need to wrap vectors with `gpuArray` manually. When the active acceleration provider supports uploads, RunMat automatically constructs the grid on the host and keeps the outputs on the GPU. Supplying a `'like', gpuArray(...)` prototype produces GPU outputs even when all inputs are host arrays. Until native provider hooks land, complex-valued grids remain host-side and emit a warning when GPU residency is requested.",
+    "gpu_behavior": [
+        "When the active acceleration provider implements the custom `meshgrid` hook, RunMat allocates every coordinate tensor directly on the device so large grids avoid host round-trips entirely.",
+        "If the hook is missing (or errors), RunMat gathers the 1-D axes, materialises the grids once on the host, and uploads the outputs whenever GPU residency is requested, preserving observable semantics.",
+        "Complex-valued grids always materialise on the host today; when GPU residency is requested the runtime logs a trace warning and returns host complex tensors so callers still receive correct MATLAB-compatible results."
+    ],
+    "key": "meshgrid",
+    "slug": "meshgrid",
+    "categoryPath": [
+        "array",
+        "creation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=meshgrid.js.map

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

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

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

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

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

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

package/dist/generated/builtins/min.js

@@ -0,0 +1,192 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "min",
+    "category": "math/reduction",
+    "keywords": [
+        "min",
+        "minimum",
+        "reduction",
+        "comparisonmethod",
+        "omitnan",
+        "gpu"
+    ],
+    "summary": "Return the minimum elements of scalars, vectors, matrices, or N-D tensors with MATLAB-compatible options.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": true,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Uses provider reduce_min_dim / reduce_min when available. Fallback gathers data to the host for omitnan, custom comparison modes, or complex inputs."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": true,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::reduction::min::tests",
+        "integration": "builtins::math::reduction::min::tests::min_gpu_dim1_matches_cpu"
+    },
+    "description": "`min` finds the smallest values in its input while preserving MATLAB semantics for reductions, elementwise comparisons, NaN handling, complex magnitude comparisons, and linear indexing.",
+    "behaviors": [
+        "`min(X)` on an `m × n` array reduces along the first non-singleton dimension, returning a row vector of column-wise minima and the corresponding indices (when requested).",
+        "`min(X, [], dim)` reduces along the specified dimension; `min(X, [], vecdim)` reduces along each dimension listed in `vecdim`.",
+        "`min(X, [], 'all')` collapses every element into a scalar and returns the linear index when two outputs are requested.",
+        "`min(X, [], 'linear')` is equivalent to `'all'` but guarantees that the matching index is linear over `X(:)`.",
+        "`min(X, [], ..., 'omitnan')` ignores `NaN` values inside each slice. If every element in a slice is `NaN`, the result for that slice is `NaN` and the index is `NaN`.",
+        "`min(X, [], ..., 'includenan')` (default) propagates `NaN` whenever a slice contains any `NaN` element, returning the index of the first `NaN`.",
+        "`min(A, B)` performs elementwise comparison using MATLAB's implicit expansion rules. The second output indicates whether the minimum came from `A` (index `1`) or `B` (index `2`).",
+        "Complex inputs follow MATLAB ordering: `'ComparisonMethod','auto'` (default) compares magnitudes and breaks ties using phase angles, while `'real'` compares real components first. `'abs'` is an explicit alias for magnitude ordering on real and complex inputs."
+    ],
+    "examples": [
+        {
+            "description": "Finding column-wise minima of a matrix",
+            "input": "A = [3 1 5; 4 2 6];\n[m, idx] = min(A)",
+            "output": "m   = [3 1 5];\nidx = [1 2 1]"
+        },
+        {
+            "description": "Reducing along the second dimension",
+            "input": "A = [3 1 5; 4 2 6];\n[m, idx] = min(A, [], 2)",
+            "output": "m   = [1; 2];\nidx = [2; 2]"
+        },
+        {
+            "description": "Collapsing all elements with linear indices",
+            "input": "A = reshape(1:12, [3 4]);\n[m, idx] = min(A, [], 'all')",
+            "output": "m   = 1;\nidx = 1;  % linear index into A(:)"
+        },
+        {
+            "description": "Ignoring NaN values during reduction",
+            "input": "values = [NaN 4 2; 3 NaN 1];\n[m, idx] = min(values, [], 1, 'omitnan')",
+            "output": "m   = [3 4 1];\nidx = [2 1 2]"
+        },
+        {
+            "description": "Elementwise minimum with broadcasting",
+            "input": "A = [1 4 7];\nB = [2; 3; 5];\n[C, origin] = min(A, B)",
+            "output": "C =\n     1     3     5\norigin =\n     1     2     2"
+        },
+        {
+            "description": "Comparing complex values by magnitude",
+            "input": "Z = [1+2i, 2+1i, -2+2i];\nM = min(Z);                         % magnitude ordering\nR = min(Z, [], 'ComparisonMethod', 'real')",
+            "output": "M = 2.0000 + 1.0000i\nR = 1.0000 + 2.0000i"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Can I request the linear index of the global minimum?",
+            "answer": "Yes. Use either `min(X, [], 'all')` or `min(X, [], 'linear')`. Both return a scalar minimum and the linear index into `X(:)` when you request two outputs."
+        },
+        {
+            "question": "Does `min` support `'ComparisonMethod'` for real and complex arrays?",
+            "answer": "Absolutely. `'auto'` or `'abs'` compare magnitudes; `'real'` compares the real component first. The returned values always match MATLAB, including tie-breaking rules."
+        },
+        {
+            "question": "What happens when all elements are `NaN` and `'omitnan'` is requested?",
+            "answer": "The value result is `NaN` and the index is `NaN`, matching MATLAB's behavior for empty slices."
+        },
+        {
+            "question": "Can I mix elementwise comparisons with dimension reductions?",
+            "answer": "No. `min(A, B)` performs elementwise comparisons only. Use `min(A, [], dim)` when you want reductions along specific dimensions."
+        },
+        {
+            "question": "Do GPU reductions support `'omitnan'` or custom comparison methods?",
+            "answer": "Not yet. Those requests fall back to the host implementation, which still honors MATLAB semantics. The output remains a host tensor in that case."
+        },
+        {
+            "question": "Are logical and integer inputs supported?",
+            "answer": "Yes. Logical arrays are promoted to double precision, and integer inputs are converted to double before comparison, matching MATLAB's numeric tower."
+        }
+    ],
+    "links": [
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "all",
+            "url": "./all"
+        },
+        {
+            "label": "any",
+            "url": "./any"
+        },
+        {
+            "label": "cummax",
+            "url": "./cummax"
+        },
+        {
+            "label": "cummin",
+            "url": "./cummin"
+        },
+        {
+            "label": "cumprod",
+            "url": "./cumprod"
+        },
+        {
+            "label": "cumsum",
+            "url": "./cumsum"
+        },
+        {
+            "label": "diff",
+            "url": "./diff"
+        },
+        {
+            "label": "median",
+            "url": "./median"
+        },
+        {
+            "label": "nnz",
+            "url": "./nnz"
+        },
+        {
+            "label": "prod",
+            "url": "./prod"
+        },
+        {
+            "label": "std",
+            "url": "./std"
+        },
+        {
+            "label": "var",
+            "url": "./var"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/reduction/min.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/min.rs"
+    },
+    "gpu_residency": "You typically do **not** need to call `gpuArray` manually. The fusion planner keeps tensors on the GPU between compatible kernels. When a reduction is supported by the active provider, the minimum values and indices stay on device. If a provider lacks the necessary hook, RunMat gathers data to the host, computes the result, and returns host tensors—subsequent fused GPU kernels can re-upload data when profitable.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active, tensors that already reside on the GPU stay on the device whenever the provider exposes `reduce_min_dim` (for dimension reductions) or `reduce_min` (for whole-array reductions). Requests that require `omitnan`, custom comparison modes, `'linear'` indices, or complex arithmetic gather the data to the host, compute the MATLAB-compatible result, and return the output on the host. Elementwise `min(A, B)` currently executes on the host; the planner rematerializes tensors on the GPU when follow-on fused kernels make it profitable."
+    ],
+    "key": "min",
+    "slug": "min",
+    "categoryPath": [
+        "math",
+        "reduction"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=min.js.map

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

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

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

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

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

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