runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/magic.js

@@ -0,0 +1,153 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "magic",
+    "category": "array/creation",
+    "keywords": [
+        "magic",
+        "magic square",
+        "matrix",
+        "array"
+    ],
+    "summary": "Generate an n-by-n magic square.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/magic.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Computed on the host CPU. GPU inputs are gathered and results are returned as host tensors."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::creation::magic::tests",
+        "integration": null
+    },
+    "description": "`magic(n)` returns an `n x n` matrix filled with the integers `1:n^2` such that every row, column, and main diagonal has the same sum. RunMat follows MATLAB's construction rules for odd, doubly-even, and singly-even orders.",
+    "behaviors": [
+        "`magic(n)` requires a single non-negative integer scalar `n`.",
+        "`magic(1)` returns `1`, while `magic(0)` returns an empty `0 x 0` matrix.",
+        "`magic(2)` is undefined and raises an error (no 2x2 magic square exists).",
+        "Odd, doubly-even (`n % 4 == 0`), and singly-even (`n % 4 == 2`) orders each use MATLAB's standard construction so results match MATLAB outputs."
+    ],
+    "examples": [
+        {
+            "description": "A 3x3 magic square",
+            "input": "M = magic(3)",
+            "output": "M =\n     8     1     6\n     3     5     7\n     4     9     2"
+        },
+        {
+            "description": "A 4x4 magic square",
+            "input": "M = magic(4)",
+            "output": "M =\n    16     2     3    13\n     5    11    10     8\n     9     7     6    12\n     4    14    15     1"
+        },
+        {
+            "description": "Use magic squares as structured input",
+            "input": "A = magic(5);\nresult = A * A'"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why does `magic(2)` fail?",
+            "answer": "No 2x2 magic square exists, so MATLAB (and RunMat) report an error for order 2."
+        },
+        {
+            "question": "Does `magic` accept a size vector?",
+            "answer": "No. `magic` accepts a single scalar order. Use `ones`, `zeros`, or `eye` when you need a size vector form."
+        },
+        {
+            "question": "How do I move the result to the GPU?",
+            "answer": "Call `gpuArray(magic(n))` if you need the output on the GPU. RunMat computes `magic` on the host today."
+        }
+    ],
+    "links": [
+        {
+            "label": "ones",
+            "url": "./ones"
+        },
+        {
+            "label": "eye",
+            "url": "./eye"
+        },
+        {
+            "label": "conv2",
+            "url": "./conv2"
+        },
+        {
+            "label": "colon",
+            "url": "./colon"
+        },
+        {
+            "label": "false",
+            "url": "./false"
+        },
+        {
+            "label": "fill",
+            "url": "./fill"
+        },
+        {
+            "label": "linspace",
+            "url": "./linspace"
+        },
+        {
+            "label": "logspace",
+            "url": "./logspace"
+        },
+        {
+            "label": "meshgrid",
+            "url": "./meshgrid"
+        },
+        {
+            "label": "rand",
+            "url": "./rand"
+        },
+        {
+            "label": "randi",
+            "url": "./randi"
+        },
+        {
+            "label": "randn",
+            "url": "./randn"
+        },
+        {
+            "label": "randperm",
+            "url": "./randperm"
+        },
+        {
+            "label": "range",
+            "url": "./range"
+        },
+        {
+            "label": "true",
+            "url": "./true"
+        },
+        {
+            "label": "zeros",
+            "url": "./zeros"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/creation/magic.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/creation/magic.rs"
+    },
+    "gpu_residency": "`magic` always runs on the host CPU today. If you need the result on the GPU, wrap the call in `gpuArray(...)`.",
+    "gpu_behavior": [
+        "RunMat gathers any GPU-resident inputs before evaluating `magic` and returns a host tensor. No acceleration provider hooks are defined for this builtin yet."
+    ],
+    "key": "magic",
+    "slug": "magic",
+    "categoryPath": [
+        "array",
+        "creation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=magic.js.map

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

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

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

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

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

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

package/dist/generated/builtins/mat2cell.js

@@ -0,0 +1,154 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "mat2cell",
+    "category": "cells/core",
+    "keywords": [
+        "mat2cell",
+        "cell array",
+        "partition",
+        "submatrix",
+        "block slicing",
+        "gpu fallback"
+    ],
+    "summary": "Split arrays into cell-array blocks using MATLAB-compatible dimension partitions.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "The builtin gathers gpuArray inputs back to the host because providers do not yet expose block-splitting hooks."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::cells::core::mat2cell::tests",
+        "integration": "builtins::cells::core::mat2cell::tests::mat2cell_gpu_falls_back_to_host"
+    },
+    "description": "`mat2cell` partitions an array along each dimension according to vectors of block sizes and returns those blocks inside a cell array. The result preserves the element type of the input, and each cell contains a contiguous slice of the original data.",
+    "behaviors": [
+        "Supply one size vector per dimension you want to split. Their elements must be non-negative integers that sum to the corresponding dimension of the input array.",
+        "If you omit trailing size vectors, RunMat assumes the remaining dimensions stay intact (`size(A, dim)`).",
+        "Zero-sized blocks are allowed and produce empty matrices (or empty arrays of the input type).",
+        "N-dimensional inputs are supported; the output cell array has one dimension per supplied size vector.",
+        "Inputs can be numeric, complex, logical, string, or character arrays. Struct, object, and cell arrays are not yet supported."
+    ],
+    "examples": [
+        {
+            "description": "Splitting a matrix into four quadrants",
+            "input": "A = reshape(1:16, 4, 4);\nC = mat2cell(A, [2 2], [1 3])",
+            "output": "size(C)        % => [2 2]\ndouble(C{2,2}) % => [7 11 15; 8 12 16]"
+        },
+        {
+            "description": "Splitting a column vector with only row sizes",
+            "input": "v = (1:6)';\nblocks = mat2cell(v, [2 1 3])",
+            "output": "cellfun(@numel, blocks)   % => [2; 1; 3]\nblocks{3}                 % => [4; 5; 6]"
+        },
+        {
+            "description": "Partitioning a 3-D tensor",
+            "input": "T = reshape(1:24, [3 4 2]);\nC = mat2cell(T, [1 2], [2 2], [1 1])",
+            "output": "size(C)                  % => [2 2 2]\ndouble(C{2,1,2}(:,:,1))  % => [14 17; 15 18]"
+        },
+        {
+            "description": "Using zero-sized blocks",
+            "input": "E = zeros(3, 2);\nC = mat2cell(E, [0 3], [1 1]);\ncellfun(@size, C, 'UniformOutput', false)",
+            "output": "ans{1,1} = [0 1]\nans{1,2} = [0 1]\nans{2,1} = [3 1]\nans{2,2} = [3 1]"
+        },
+        {
+            "description": "Splitting a character matrix into rows",
+            "input": "names = ['foo '; 'bar '; 'baz '];\nC = mat2cell(names, [1 2], size(names, 2))",
+            "output": "C{1,1}   % => 'foo '\nC{2,1}   % => ['bar '; 'baz ']"
+        },
+        {
+            "description": "Working with logical arrays",
+            "input": "mask = logical([1 0 1; 0 1 0]);\ncells = mat2cell(mask, 2, [1 1 1])",
+            "output": "cells{1,2}   % => logical column vector [0; 1]\nclass(cells{1,2})  % => 'logical'"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Do the partition vectors have to sum exactly to the dimension size?",
+            "answer": "Yes. Each size vector must consist of non-negative integers whose sum matches the corresponding dimension of the input array. RunMat raises an error when the sums differ."
+        },
+        {
+            "question": "What happens if I omit trailing dimension vectors?",
+            "answer": "RunMat mirrors MATLAB: omitted trailing vectors are treated as a single block that covers the entire dimension (`size(A, dim)`), so many common 2-D use cases only need two vectors."
+        },
+        {
+            "question": "Are zero-sized blocks allowed?",
+            "answer": "Yes. A zero entry in a partition vector produces an empty array in the corresponding cell. This is useful when you need placeholders that preserve grid structure."
+        },
+        {
+            "question": "What element types are supported?",
+            "answer": "Numeric, complex, logical, string, and character arrays are supported today. Struct arrays, object arrays, and cell arrays will gain support in a future update."
+        },
+        {
+            "question": "Does `mat2cell` copy the data?",
+            "answer": "Yes. Each cell receives its own copy of the underlying block so that you can modify the cell contents without affecting other cells or the original array."
+        },
+        {
+            "question": "What does mat2cell do in MATLAB?",
+            "answer": "`mat2cell(X, rowSizes, colSizes)` divides matrix `X` into a cell array of sub-matrices. The partition vectors specify the row and column sizes of each block, and must sum to the dimension sizes of `X`."
+        },
+        {
+            "question": "How is mat2cell different from num2cell?",
+            "answer": "`num2cell` splits a matrix into individual scalar cells (one element per cell), while `mat2cell` splits into sub-matrices of specified sizes. Use `mat2cell` when you need contiguous blocks."
+        },
+        {
+            "question": "Can I use mat2cell on 3-D arrays?",
+            "answer": "Yes. Provide partition vectors for each dimension: `mat2cell(X, rowSizes, colSizes, pageSizes)`. Omitted trailing dimensions are treated as a single partition equal to the full size."
+        },
+        {
+            "question": "How do I convert a cell array back to a matrix?",
+            "answer": "Use `cell2mat(C)` to concatenate the cells back into a single matrix. Each cell must contain a numeric array, and the sizes must be consistent along concatenation dimensions."
+        }
+    ],
+    "links": [
+        {
+            "label": "cell",
+            "url": "./cell"
+        },
+        {
+            "label": "cell2mat",
+            "url": "./cell2mat"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "cellfun",
+            "url": "./cellfun"
+        },
+        {
+            "label": "cellstr",
+            "url": "./cellstr"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/cells/core/mat2cell.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/cells/core/mat2cell.rs"
+    },
+    "gpu_residency": "The current implementation gathers GPU inputs to the host, produces host cell arrays, and returns CPU-resident tensors inside each cell. Explicit `gpuArray` calls are not required; once GPU providers offer block-splitting hooks, mat2cell will keep results on the device automatically.",
+    "gpu_behavior": [
+        "When the input is a `gpuArray`, RunMat gathers it back to the host before performing the partition, and the resulting cells contain host tensors. This matches MATLAB semantics except for the residency—providers do not yet offer on-device block-splitting hooks. Once such hooks become available, RunMat can keep results on the GPU with no user code changes."
+    ],
+    "key": "mat2cell",
+    "slug": "mat2cell",
+    "categoryPath": [
+        "cells",
+        "core"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=mat2cell.js.map

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

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

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

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

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

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

@@ -0,0 +1,192 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "max",
+    "category": "math/reduction",
+    "keywords": [
+        "max",
+        "maximum",
+        "reduction",
+        "comparisonmethod",
+        "omitnan",
+        "gpu"
+    ],
+    "summary": "Return the maximum 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_max_dim / reduce_max 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::max::tests",
+        "integration": "builtins::math::reduction::max::tests::max_gpu_dim1_matches_cpu"
+    },
+    "description": "`max` returns the largest values in its input while preserving MATLAB semantics for reductions, elementwise comparisons, NaN handling, complex magnitude comparisons, and linear indexing.",
+    "behaviors": [
+        "`max(X)` on an `m × n` array reduces along the first non-singleton dimension, returning a row vector of column-wise maxima and the corresponding indices (when requested).",
+        "`max(X, [], dim)` reduces along the specified dimension; `max(X, [], vecdim)` reduces along each dimension listed in `vecdim`.",
+        "`max(X, [], 'all')` collapses every element into a scalar and returns the linear index when two outputs are requested.",
+        "`max(X, [], 'linear')` is equivalent to `'all'` but guarantees that the matching index is linear over `X(:)`.",
+        "`max(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`.",
+        "`max(X, [], ..., 'includenan')` (default) propagates `NaN` whenever a slice contains any `NaN` element, returning the index of the first `NaN`.",
+        "`max(A, B)` performs elementwise comparison using MATLAB's implicit expansion rules. The second output indicates whether the maximum 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 maxima of a matrix",
+            "input": "A = [3 1 5; 4 2 6];\n[m, idx] = max(A)",
+            "output": "m   = [4 2 6];\nidx = [2 2 2]"
+        },
+        {
+            "description": "Reducing along the second dimension",
+            "input": "A = [3 1 5; 4 2 6];\n[m, idx] = max(A, [], 2)",
+            "output": "m   = [5; 6];\nidx = [3; 3]"
+        },
+        {
+            "description": "Collapsing all elements with linear indices",
+            "input": "A = reshape(1:12, [3 4]);\n[m, idx] = max(A, [], 'all')",
+            "output": "m   = 12;\nidx = 12;  % linear index into A(:)"
+        },
+        {
+            "description": "Ignoring NaN values during reduction",
+            "input": "values = [NaN 4 2; 3 NaN 1];\n[m, idx] = max(values, [], 1, 'omitnan')",
+            "output": "m   = [3 4 2];\nidx = [2 1 1]"
+        },
+        {
+            "description": "Elementwise maximum with broadcasting",
+            "input": "A = [1 4 7];\nB = [2; 3; 5];\n[C, origin] = max(A, B)",
+            "output": "C =\n     2     4     7\n     3     4     7\n     5     5     7\n\norigin =\n     2     1     1\n     2     1     1\n     2     2     1"
+        },
+        {
+            "description": "Comparing complex values by magnitude",
+            "input": "Z = [1+2i, 2+1i, -2+2i];\nM = max(Z);                         % magnitude ordering\nR = max(Z, [], 'ComparisonMethod', 'real')",
+            "output": "M = -2.0000 + 2.0000i\nR = 2.0000 + 1.0000i"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Can I request the linear index of the global maximum?",
+            "answer": "Yes. Use either `max(X, [], 'all')` or `max(X, [], 'linear')`. Both return a scalar maximum and the linear index into `X(:)` when you request two outputs."
+        },
+        {
+            "question": "Does `max` 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. `max(A, B)` performs elementwise comparisons only. Use `max(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": "min",
+            "url": "./min"
+        },
+        {
+            "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/max.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/max.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 maximum 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_max_dim` (for dimension reductions) or `reduce_max` (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 `max(A, B)` currently executes on the host; the planner rematerializes tensors on the GPU when follow-on fused kernels make it profitable."
+    ],
+    "key": "max",
+    "slug": "max",
+    "categoryPath": [
+        "math",
+        "reduction"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=max.js.map

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

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

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

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

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

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