runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/var.js

@@ -0,0 +1,193 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "var",
+    "category": "math/reduction",
+    "keywords": [
+        "var",
+        "variance",
+        "statistics",
+        "gpu",
+        "omitnan",
+        "all"
+    ],
+    "summary": "Variance 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": "Falls back to host when 'omitnan' is requested or the provider lacks std/elementwise kernels for the squaring step."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::reduction::var::tests",
+        "integration": "builtins::math::reduction::var::tests::var_gpu_provider_roundtrip",
+        "gpu": "builtins::math::reduction::var::tests::var_wgpu_dim1_matches_cpu"
+    },
+    "description": "`var(x)` measures the spread of the elements in `x` by returning their variance. By default, RunMat matches MATLAB’s sample definition (dividing by `n-1`) and works along the first non-singleton dimension.",
+    "behaviors": [
+        "`var(X)` on an `m × n` matrix returns a `1 × n` row vector with the sample variance of each column.",
+        "`var(X, 1)` switches to population normalisation (`n` in the denominator). Use `var(X, 0)` or `var(X, [])` to keep the default sample behaviour.",
+        "`var(X, flag, dim)` lets you pick both the normalisation (`flag = 0` sample, `1` population, or `[]`) and the dimension to reduce. `var(X, flag, 'all')` collapses every dimension, while `var(X, flag, vecdim)` accepts a dimension vector such as `[1 3]` and reduces all listed axes in a single call.",
+        "Strings like `'omitnan'` and `'includenan'` decide whether `NaN` values are skipped or propagated.",
+        "Logical inputs are promoted to double precision before reduction so that results follow MATLAB’s numeric rules.",
+        "Empty slices return `NaN` with MATLAB-compatible shapes. Scalars return `0`, regardless of the normalisation mode.",
+        "Dimensions greater than `ndims(X)` leave the input unchanged.",
+        "Weighted variances (`flag` as a vector) are not implemented yet; RunMat reports a descriptive error when they are requested.\n\nComplex tensors are not currently supported; convert them to real magnitudes manually before calling `var`."
+    ],
+    "examples": [
+        {
+            "description": "Sample variance of a vector",
+            "input": "x = [1 2 3 4 5];\nv = var(x);                 % uses flag = 0 (sample) by default",
+            "output": "v = 2.5"
+        },
+        {
+            "description": "Population variance of each column",
+            "input": "A = [1 3 5; 2 4 6];\nvpop = var(A, 1);           % divide by n instead of n-1",
+            "output": "vpop = [0.25 0.25 0.25]"
+        },
+        {
+            "description": "Collapsing every dimension at once",
+            "input": "B = reshape(1:12, [3 4]);\noverall = var(B, 0, 'all')",
+            "output": "overall = 13"
+        },
+        {
+            "description": "Reducing across multiple dimensions",
+            "input": "C = cat(3, [1 2; 3 4], [5 6; 7 8]);\nsliceVariance = var(C, [], [1 3]);   % keep columns, reduce rows & pages",
+            "output": "sliceVariance = [6.6667 6.6667]"
+        },
+        {
+            "description": "Ignoring NaN values",
+            "input": "D = [1 NaN 3; 2 4 NaN];\nrowVariance = var(D, 0, 2, 'omitnan')",
+            "output": "rowVariance = [2; 2]"
+        },
+        {
+            "description": "Variance on the GPU without manual `gpuArray`",
+            "input": "G = rand(1024, 512);\nspread = var(G, 1, 'all');   % stays on the GPU when the provider supports std reductions"
+        },
+        {
+            "description": "Preserving default behaviour with an empty normalisation flag",
+            "input": "C = [1 2; 3 4];\nrowVariance = var(C, [], 2)",
+            "output": "rowVariance = [0.5; 0.5]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What values can I pass as the normalisation flag?",
+            "answer": "Use `0` (or `[]`) for the sample definition, `1` for population. RunMat rejects non-scalar weight vectors and reports that weighted variances are not implemented yet."
+        },
+        {
+            "question": "How can I collapse multiple dimensions?",
+            "answer": "Pass a vector of dimensions such as `var(A, [], [1 3])`. You can also use `'all'` to collapse every dimension into a single scalar."
+        },
+        {
+            "question": "How do `'omitnan'` and `'includenan'` work?",
+            "answer": "`'omitnan'` skips NaN values; if every element in a slice is NaN the result is NaN. `'includenan'` (the default) propagates a single NaN to the output slice."
+        },
+        {
+            "question": "What happens if I request a dimension greater than `ndims(X)`?",
+            "answer": "RunMat returns the input unchanged so that MATLAB-compatible code relying on that behaviour continues to work. Scalars still return `0` to follow MATLAB’s edge-case semantics."
+        },
+        {
+            "question": "Are complex inputs supported?",
+            "answer": "Not yet. RunMat currently requires real inputs for `var`. Convert complex data to magnitude or separate real/imaginary parts before calling the builtin."
+        }
+    ],
+    "links": [
+        {
+            "label": "std",
+            "url": "./std"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "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": "max",
+            "url": "./max"
+        },
+        {
+            "label": "median",
+            "url": "./median"
+        },
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "nnz",
+            "url": "./nnz"
+        },
+        {
+            "label": "prod",
+            "url": "./prod"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/reduction/var.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/var.rs"
+    },
+    "gpu_residency": "Usually you do not need to call `gpuArray` manually. The fusion planner keeps tensors on the GPU across fused expressions and gathers them only when necessary. For explicit control or MATLAB compatibility, you can still call `gpuArray`/`gather` yourself.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active, device-resident tensors remain on the GPU whenever the provider implements the relevant hooks. Providers that expose `reduce_std_dim`/`reduce_std` execute the reduction in-place on the device; the runtime squares the resulting standard deviation tensor with an elementwise multiply in device memory. Whenever `'omitnan'`, multi-axis reductions, or unsupported shapes are requested, RunMat transparently gathers the data to the host, computes the result there, and materialises the variance tensor before returning."
+    ],
+    "key": "var",
+    "slug": "var",
+    "categoryPath": [
+        "math",
+        "reduction"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=var.js.map

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

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

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

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

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

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

package/dist/generated/builtins/vertcat.js

@@ -0,0 +1,182 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "vertcat",
+    "category": "array/shape",
+    "keywords": [
+        "vertcat",
+        "vertical concatenation",
+        "stack rows",
+        "square brackets",
+        "gpu"
+    ],
+    "summary": "Stack inputs top-to-bottom (dimension 1) exactly like MATLAB's semicolon syntax.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Delegates to cat with dim=1; providers that expose cat run entirely on the GPU, otherwise RunMat gathers to the host and re-uploads the result."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": null,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::shape::vertcat::tests",
+        "integration": [
+            "builtins::array::shape::vertcat::tests::vertcat_gpu_roundtrip",
+            "builtins::array::shape::vertcat::tests::vertcat_like_gpu_from_host_inputs"
+        ]
+    },
+    "description": "`vertcat(A1, A2, …)` vertically concatenates its inputs, matching the behavior of MATLAB's semicolon array construction `[A1; A2; …]`. It is the standard way to stack matrices, vectors, or higher-dimensional slices on top of each other.",
+    "behaviors": [
+        "Hard-codes `dim = 1`. All inputs must agree on every dimension except the first.",
+        "Accepts numeric, logical, complex, character, string, and cell arrays with MATLAB-compatible type checking. Mixing classes is an error.",
+        "Scalars are treated as `1×1`, enabling concise row-building such as `vertcat(1, 2, 3)`.",
+        "Empty inputs participate naturally. If any shared dimension is zero, the result is empty with the expected shape.",
+        "The optional trailing `'like', prototype` pair forces the output to match the prototype's data residency (CPU vs GPU) and numeric flavour.",
+        "Mixing `gpuArray` inputs with host inputs is disallowed. Convert explicitly via `gpuArray` or `gather` to control residency."
+    ],
+    "examples": [
+        {
+            "description": "Stacking matrices by adding rows",
+            "input": "A = [1 2; 3 4];\nB = [5 6; 7 8];\nC = vertcat(A, B)",
+            "output": "C =\n     1     2\n     3     4\n     5     6\n     7     8"
+        },
+        {
+            "description": "Building a column vector from scalars",
+            "input": "col = vertcat(1, 2, 3, 4)",
+            "output": "col =\n     1\n     2\n     3\n     4"
+        },
+        {
+            "description": "Combining character arrays into taller text blocks",
+            "input": "top = ['RunMat'];\nbottom = ['Rocks!'];\nbanner = vertcat(top, bottom)"
+        },
+        {
+            "description": "Joining string arrays into multi-row tables",
+            "input": "header = [\"Name\" \"Score\"];\nrows = [\"Alice\" \"98\"; \"Bob\" \"92\"];\ntable = vertcat(header, rows)"
+        },
+        {
+            "description": "Preserving logical masks when stacking",
+            "input": "mask1 = logical([1 0 1]);\nmask2 = logical([0 1 0]);\nstacked = vertcat(mask1, mask2)"
+        },
+        {
+            "description": "Extending cell arrays downwards",
+            "input": "row1 = {1, \"low\"};\nrow2 = {2, \"high\"};\ngrid = vertcat(row1, row2)"
+        },
+        {
+            "description": "Keeping gpuArray inputs resident on the device",
+            "input": "G1 = gpuArray(rand(128, 256));\nG2 = gpuArray(rand(64, 256));\nstacked = vertcat(G1, G2)"
+        },
+        {
+            "description": "Requesting GPU output with the `'like'` prototype",
+            "input": "proto = gpuArray.zeros(1, 3);\nresult = vertcat([1 2 3], [4 5 6], \"like\", proto)"
+        },
+        {
+            "description": "Working with empty rows without surprises",
+            "input": "empty = zeros(0, 3);\ncombo = vertcat(empty, empty)"
+        },
+        {
+            "description": "Stacking complex matrices preserves imaginary parts",
+            "input": "z1 = complex([1 2], [3 4]);\nz2 = complex([5 6], [7 8]);\njoined = vertcat(z1, z2)"
+        }
+    ],
+    "faqs": [],
+    "links": [
+        {
+            "label": "`cat`",
+            "url": "./cat"
+        },
+        {
+            "label": "`horzcat`",
+            "url": "./horzcat"
+        },
+        {
+            "label": "`reshape`",
+            "url": "./reshape"
+        },
+        {
+            "label": "`gpuArray`",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "`gather`",
+            "url": "./gather"
+        },
+        {
+            "label": "circshift",
+            "url": "./circshift"
+        },
+        {
+            "label": "diag",
+            "url": "./diag"
+        },
+        {
+            "label": "flip",
+            "url": "./flip"
+        },
+        {
+            "label": "fliplr",
+            "url": "./fliplr"
+        },
+        {
+            "label": "flipud",
+            "url": "./flipud"
+        },
+        {
+            "label": "ipermute",
+            "url": "./ipermute"
+        },
+        {
+            "label": "kron",
+            "url": "./kron"
+        },
+        {
+            "label": "permute",
+            "url": "./permute"
+        },
+        {
+            "label": "repmat",
+            "url": "./repmat"
+        },
+        {
+            "label": "rot90",
+            "url": "./rot90"
+        },
+        {
+            "label": "squeeze",
+            "url": "./squeeze"
+        },
+        {
+            "label": "tril",
+            "url": "./tril"
+        },
+        {
+            "label": "triu",
+            "url": "./triu"
+        }
+    ],
+    "source": {
+        "label": "crates/runmat-runtime/src/builtins/array/shape/vertcat.rs",
+        "url": "crates/runmat-runtime/src/builtins/array/shape/vertcat.rs"
+    },
+    "gpu_behavior": [
+        "`vertcat` delegates to `cat(dim = 1, …)`. When the active acceleration provider implements the `cat` hook, concatenation happens entirely on the GPU, keeping `gpuArray` inputs resident and avoiding costly round-trips. Providers that lack this hook trigger a transparent fallback: RunMat gathers the operands to the host, concatenates them with MATLAB semantics, and uploads the result back to the originating device so downstream code still sees a `gpuArray`. This mirrors MATLAB's explicit GPU workflows while keeping RunMat's auto-offload planner informed."
+    ],
+    "key": "vertcat",
+    "slug": "vertcat",
+    "categoryPath": [
+        "array",
+        "shape"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=vertcat.js.map

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

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

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

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

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

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

package/dist/generated/builtins/view.js

@@ -0,0 +1,78 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "view",
+    "category": "plotting",
+    "keywords": [
+        "view",
+        "3-D camera",
+        "azimuth elevation",
+        "matlab view",
+        "rotate 3-D plot"
+    ],
+    "summary": "Control 3-D camera angles for surfaces and spatial plots using azimuth/elevation views and MATLAB `view` semantics.",
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::view::tests"
+    },
+    "description": "`view` reads or updates the camera orientation for the current axes or an explicit axes handle. In RunMat it stores subplot-local azimuth and elevation state, supports MATLAB `view(2)`, `view(3)`, `view([az el])`, and `view(az, el)` call forms, and integrates with the same handle/property system used by `get` and `set`.",
+    "behaviors": [
+        "`view` with no angle arguments queries the current `[az el]` pair.",
+        "`view(2)` selects the standard top-down 2-D camera and `view(3)` restores the standard 3-D camera preset.",
+        "Explicit azimuth/elevation values can be passed as two scalars or as a two-element vector.",
+        "View state is subplot-local and does not leak across different axes in a subplot grid.",
+        "Axes handles can be passed explicitly so camera changes target a specific subplot rather than whichever axes happens to be current."
+    ],
+    "examples": [
+        {
+            "description": "Set an explicit 3-D camera angle",
+            "input": "[X, Y] = meshgrid(linspace(-2, 2, 60), linspace(-2, 2, 60));\nZ = sin(X.^2 + Y.^2);\nsurf(X, Y, Z);\nview(45, 30);"
+        },
+        {
+            "description": "Use MATLAB-style view presets",
+            "input": "[X, Y] = meshgrid(linspace(-3, 3, 40), linspace(-3, 3, 40));\nZ = sin(X) .* cos(Y);\nsurf(X, Y, Z);\nview(2);\nview(3);"
+        },
+        {
+            "description": "Query a subplot-local camera",
+            "input": "ax = subplot(1, 2, 2);\nplot3(cos(0:0.1:5), sin(0:0.1:5), 0:0.1:5);\nview(ax, [60 20]);\nget(ax, 'View')",
+            "output": "% Returns a 1x2 vector [60 20]"
+        }
+    ],
+    "links": [
+        {
+            "label": "plot3",
+            "url": "./plot3"
+        },
+        {
+            "label": "scatter3",
+            "url": "./scatter3"
+        },
+        {
+            "label": "surf",
+            "url": "./surf"
+        },
+        {
+            "label": "zlabel",
+            "url": "./zlabel"
+        },
+        {
+            "label": "get",
+            "url": "./get"
+        },
+        {
+            "label": "set",
+            "url": "./set"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/view.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/view.rs"
+    },
+    "key": "view",
+    "slug": "view",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=view.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"view.js","sourceRoot":"","sources":["../../../src/generated/builtins/view.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,MAAM;QACN,YAAY;QACZ,mBAAmB;QACnB,aAAa;QACb,iBAAiB;KAClB;IACD,SAAS,EAAE,qHAAqH;IAChI,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,iCAAiC;KAC1C;IACD,aAAa,EAAE,mUAAmU;IAClV,WAAW,EAAE;QACX,oEAAoE;QACpE,2GAA2G;QAC3G,4FAA4F;QAC5F,wFAAwF;QACxF,qIAAqI;KACtI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,oHAAoH;SAC9H;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,yHAAyH;SACnI;QACD;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,0GAA0G;YACnH,QAAQ,EAAE,gCAAgC;SAC3C;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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