runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/histcounts.js

@@ -0,0 +1,154 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "histcounts",
+    "category": "stats/hist",
+    "keywords": [
+        "histcounts",
+        "histogram",
+        "binning",
+        "normalization",
+        "probability",
+        "cdf",
+        "gpu"
+    ],
+    "summary": "Count observations in numeric arrays using configurable histogram bins.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/histcounts.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": true,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Falls back to host execution today; providers can implement a custom histogram kernel via the `histcounts` hook."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::stats::hist::histcounts::tests",
+        "integration": "builtins::stats::hist::histcounts::tests::histcounts_gpu_roundtrip",
+        "gpu": "builtins::stats::hist::histcounts::tests::histcounts_wgpu_roundtrip"
+    },
+    "description": "`histcounts` tallies the number of elements that fall within each histogram bin. Bins can be specified explicitly, derived from a target bin width, or chosen by the default heuristics so that both simple and advanced workflows mirror MathWorks MATLAB semantics.",
+    "behaviors": [
+        "`histcounts(X)` flattens numeric or logical inputs column-major and returns a row vector of counts spread across ten equal-width bins spanning the data range.",
+        "`histcounts(X, N)` partitions the data into `N` equally spaced bins.",
+        "`histcounts(X, edges)` counts observations using the supplied bin edges.",
+        "Name/value pairs such as `'BinWidth'`, `'BinLimits'`, `'NumBins'`, `'BinEdges'`, `'BinMethod'`, and `'Normalization'` follow MATLAB's precedence rules and validation logic.",
+        "Values outside the bin limits are excluded. The last bin includes its upper edge while all other bins are half-open on the right.",
+        "`NaN` values are ignored; `Inf` and `-Inf` participate when the edges cover them."
+    ],
+    "examples": [
+        {
+            "description": "Counting values with custom bin counts",
+            "input": "data = [1 2 2 4 5 7];\n[counts, edges] = histcounts(data, 3)",
+            "output": "counts = [3 1 2];\nedges  = [1 3 5 7]"
+        },
+        {
+            "description": "Using explicit bin edges",
+            "input": "edges = [0 1 2 3];\ncounts = histcounts([0.1 0.5 0.9 1.2 1.8 2.1], edges)",
+            "output": "counts = [3 2 1]"
+        },
+        {
+            "description": "Setting bin width and limits",
+            "input": "[counts, edges] = histcounts([5 7 8 10 12], 'BinWidth', 2, 'BinLimits', [4 12])",
+            "output": "counts = [1 1 1 2];\nedges  = [4 6 8 10 12]"
+        },
+        {
+            "description": "Choosing an automatic binning method",
+            "input": "[counts, edges] = histcounts(randn(1, 500), 'BinMethod', 'sturges')",
+            "output": "numel(counts) = ceil(log2(500) + 1);   % 10 bins"
+        },
+        {
+            "description": "Normalising counts to probabilities",
+            "input": "counts = histcounts([0.2 0.4 1.1 1.4 1.8 2.5], [0 1 2 3], 'Normalization', 'probability')",
+            "output": "counts = [0.3333 0.5000 0.1667]"
+        },
+        {
+            "description": "Building a cumulative distribution",
+            "input": "counts = histcounts([1 2 2 3], [0 1 2 3], 'Normalization', 'cdf')",
+            "output": "counts = [0 0.25 1]"
+        },
+        {
+            "description": "Counting values stored on a GPU array",
+            "input": "G = gpuArray([0.5 1.5 2.5]);\n[counts, edges] = histcounts(G, [0 1 2 3]);   % counts/edges return as CPU arrays",
+            "output": "counts = [1 1 1];\nedges  = [0 1 2 3]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why does the last bin include its upper edge?",
+            "answer": "To match MATLAB semantics each bin is `[left, right)` except for the final bin, which is `[left, right]`. This ensures the maximum finite value is always counted."
+        },
+        {
+            "question": "How are `NaN` values handled?",
+            "answer": "They are ignored entirely and do not contribute to any bin count. Infinite values participate as long as the bin edges include them."
+        },
+        {
+            "question": "What happens when all observations are identical?",
+            "answer": "RunMat mirrors MATLAB by collapsing the histogram to a single bin centred on the shared value unless you explicitly supply edges, limits, or a bin width."
+        },
+        {
+            "question": "Does `histcounts` support non-double inputs?",
+            "answer": "Yes. Logical inputs are promoted to doubles, integer types are converted to `double`, and gpuArray inputs are gathered to host memory in this release."
+        },
+        {
+            "question": "Can I request both `'BinEdges'` and `'BinWidth'`?",
+            "answer": "No. Bin specifications are mutually exclusive—choose one of `'BinEdges'`, `'BinWidth'`, or `'NumBins'`, optionally constrained by `'BinLimits'`."
+        },
+        {
+            "question": "How do probability and PDF normalisations differ?",
+            "answer": "`'probability'` scales counts so that they sum to one. `'pdf'` divides by both bin width and the total count, matching MATLAB's probability-density definition."
+        },
+        {
+            "question": "Do outputs stay on the GPU when the input is a `gpuArray`?",
+            "answer": "Until specialised provider hooks land, RunMat gathers GPU data to the CPU and returns host-resident outputs. Use `gather` only for clarity; the values are already in host memory."
+        }
+    ],
+    "links": [
+        {
+            "label": "linspace",
+            "url": "./linspace"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "rand",
+            "url": "./rand"
+        },
+        {
+            "label": "histcounts2",
+            "url": "./histcounts2"
+        }
+    ],
+    "source": {
+        "label": "crates/runmat-runtime/src/builtins/stats/hist/histcounts.rs",
+        "url": "crates/runmat-runtime/src/builtins/stats/hist/histcounts.rs"
+    },
+    "gpu_behavior": [
+        "When the input arrives as a `gpuArray`, RunMat gathers the samples to host memory, executes the CPU reference implementation, and materialises the results as ordinary tensors. The builtin is registered as a sink, so fusion plans flush residency before histogramming and the outputs always live on the host today. The acceleration layer exposes a `histcounts` provider hook; once GPU kernels are implemented, existing code will pick up device-side execution automatically."
+    ],
+    "key": "histcounts",
+    "slug": "histcounts",
+    "categoryPath": [
+        "stats",
+        "hist"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=histcounts.js.map

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

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

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

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

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

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

package/dist/generated/builtins/histcounts2.js

@@ -0,0 +1,148 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "histcounts2",
+    "category": "stats/hist",
+    "keywords": [
+        "histcounts2",
+        "2d histogram",
+        "joint distribution",
+        "binning",
+        "probability",
+        "gpu"
+    ],
+    "summary": "Count paired observations into two-dimensional histogram bins.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/histcounts2.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": true,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Falls back to host execution today; providers can attach a `histcounts2` hook for device kernels."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::stats::hist::histcounts2::tests",
+        "integration": "builtins::stats::hist::histcounts2::tests::histcounts2_gpu_roundtrip",
+        "gpu": "builtins::stats::hist::histcounts2::tests::histcounts2_wgpu_roundtrip"
+    },
+    "description": "`histcounts2(X, Y)` bins paired observations from `X` and `Y` into a rectangular two-dimensional histogram. Each bin counts the number of pairs whose `X` component lies in a horizontal interval and whose `Y` component lies in a vertical interval, mirroring MathWorks MATLAB behaviour.",
+    "behaviors": [
+        "`histcounts2(X, Y)` flattens both inputs column-major, ensuring they contain the same number of elements, and fills a `numel(Xedges) - 1` by `numel(Yedges) - 1` matrix of bin counts.",
+        "Bins are half-open on the right except for the last column and row, which include their upper edges so the maximum finite values are counted.",
+        "Optional arguments let you specify bin counts, explicit edges, bin limits, bin widths, and automatic binning heuristics independently for the `X` and `Y` axes.",
+        "Name/value pairs such as `'NumBins'`, `'XBinEdges'`, `'YBinEdges'`, `'XBinWidth'`, `'YBinWidth'`, `'BinMethod'`, and `'Normalization'` follow MATLAB precedence and validation rules.",
+        "Pairs containing `NaN` in either coordinate are ignored. Infinite values participate when the chosen edges include them."
+    ],
+    "examples": [
+        {
+            "description": "Counting paired values with explicit edges",
+            "input": "X = [0.5 1.5 2.5 3.5];\nY = [0.2 0.9 1.4 2.8];\n[N, Xedges, Yedges] = histcounts2(X, Y, [0 1 2 3 4], [0 1 2 3])",
+            "output": "N = [1 0 0; 1 0 0; 0 1 0; 0 0 1];\nXedges = [0 1 2 3 4];\nYedges = [0 1 2 3]"
+        },
+        {
+            "description": "Specifying separate bin counts for each axis",
+            "input": "X = [1 2 3 4];\nY = [1 2 3 4];\nN = histcounts2(X, Y, 2, 4)",
+            "output": "size(N) = [2 4];\nsum(N, \"all\") = 4"
+        },
+        {
+            "description": "Using different bin widths for X and Y",
+            "input": "X = [1 1.5 2.4 3.7];\nY = [2 2.2 2.9 3.1];\n[N, Xedges, Yedges] = histcounts2(X, Y, 'XBinWidth', 1, 'YBinWidth', 0.5)",
+            "output": "diff(Xedges) = [1 1 1];\ndiff(Yedges(1:3)) = [0.5 0.5];\nsum(N, \"all\") = 4"
+        },
+        {
+            "description": "Normalizing a 2-D histogram to probabilities",
+            "input": "X = [0.2 0.4 1.1 1.5];\nY = [0.1 0.8 1.2 1.9];\nN = histcounts2(X, Y, [0 1 2], [0 1 2], 'Normalization', 'probability')",
+            "output": "N = [0.5 0.0; 0.0 0.5]"
+        },
+        {
+            "description": "Ignoring NaN values in paired data",
+            "input": "X = [1 2 NaN 3];\nY = [2 2 2 NaN];\nN = histcounts2(X, Y, [0 1 2 3], [0 1 2 3])",
+            "output": "sum(N, \"all\") = 2"
+        },
+        {
+            "description": "Histogramming gpuArray inputs without manual gather",
+            "input": "Gx = gpuArray([0.5 1.5 2.5]);\nGy = gpuArray([1.0 1.1 2.9]);\n[counts, Xedges, Yedges] = histcounts2(Gx, Gy, [0 1 2 3], [0 2 3])",
+            "output": "isa(counts, 'double')      % counts are returned on the CPU\ncounts = [1 0; 1 0; 0 1]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Do `X` and `Y` need the same size?",
+            "answer": "Yes. `histcounts2` requires both inputs to contain the same number of elements. RunMat mirrors MATLAB by raising an error when the sizes do not match."
+        },
+        {
+            "question": "How are the bin edges interpreted?",
+            "answer": "All interior bins are `[left, right)`, while the last row and column are `[left, right]`, so the largest finite values are counted."
+        },
+        {
+            "question": "What happens to `NaN`, `Inf`, or `-Inf` values?",
+            "answer": "Pairs containing `NaN` in either coordinate are ignored. Infinite values participate when the specified edges include them; otherwise, they are excluded just like MATLAB."
+        },
+        {
+            "question": "Can I mix explicit edges on one axis with automatic binning on the other?",
+            "answer": "Yes. You can supply `'XBinEdges'` while leaving the `Y` axis to be determined by `'NumBins'`, `'YBinWidth'`, or the default heuristics."
+        },
+        {
+            "question": "Which normalisation modes are supported?",
+            "answer": "`'count'`, `'probability'`, `'countdensity'`, `'pdf'`, `'cumcount'`, and `'cdf'` are implemented. `'cdf'` and `'cumcount'` operate in column-major order so the result matches MATLAB's cumulative behaviour."
+        },
+        {
+            "question": "How do I request integer-aligned bins?",
+            "answer": "Use `'BinMethod', 'integers'` or `'XBinMethod'/'YBinMethod'` with the value `'integers'`. RunMat ensures the resulting edges align with integer boundaries, respecting any supplied bin limits."
+        },
+        {
+            "question": "What does histcounts2 do in MATLAB?",
+            "answer": "`histcounts2` bins paired observations into a two-dimensional histogram. It accepts two vectors `X` and `Y` of equal length and returns a matrix of bin counts plus the bin edges for each axis."
+        },
+        {
+            "question": "How is histcounts2 different from histcounts?",
+            "answer": "`histcounts` bins data along a single dimension, while `histcounts2` bins paired data along two dimensions simultaneously, producing a 2-D count matrix."
+        },
+        {
+            "question": "Can I use histcounts2 on GPU arrays in RunMat?",
+            "answer": "Yes. RunMat supports `histcounts2` on GPU arrays with `f32` and `f64` precision. GPU providers can attach a device kernel for full hardware acceleration."
+        }
+    ],
+    "links": [
+        {
+            "label": "histcounts",
+            "url": "./histcounts"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        }
+    ],
+    "source": {
+        "label": "crates/runmat-runtime/src/builtins/stats/hist/histcounts2.rs",
+        "url": "crates/runmat-runtime/src/builtins/stats/hist/histcounts2.rs"
+    },
+    "gpu_residency": "As with other RunMat histogram routines, you do not need to call `gpuArray` explicitly just to obtain GPU execution. Once providers implement the `histcounts2` hook, the fusion planner will keep residency on the device automatically. Until then, the builtin gathers data to the host and returns CPU tensors even when inputs originate on the GPU, matching MATLAB semantics after an explicit `gather`.",
+    "gpu_behavior": [
+        "When either input is a `gpuArray`, RunMat gathers the samples back to host memory, performs the reference CPU implementation, and returns dense CPU tensors for the histogram and edges. The acceleration layer exposes a `histcounts2` provider hook; once kernels land, the runtime will automatically keep residency on the GPU and skip gathering. The builtin is registered as a sink, so fusion plans flush GPU residency before histogramming and the current implementation always yields host-resident outputs."
+    ],
+    "key": "histcounts2",
+    "slug": "histcounts2",
+    "categoryPath": [
+        "stats",
+        "hist"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=histcounts2.js.map

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

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

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

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

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

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

package/dist/generated/builtins/histogram.js

@@ -0,0 +1,88 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "histogram",
+    "category": "plotting",
+    "keywords": [
+        "histogram",
+        "histogram object",
+        "bin edges",
+        "normalized histogram",
+        "matlab histogram",
+        "distribution analysis"
+    ],
+    "summary": "Create histogram objects with bin-edge semantics, normalization controls, and MATLAB `histogram` workflows.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`histogram` uses histogram evaluation with a handle-based plotting object interface."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::histogram::tests"
+    },
+    "description": "`histogram` is the object-style histogram builtin in RunMat. Unlike legacy `hist`, it uses bin-edge semantics, supports normalization workflows through the histogram evaluation path, and returns a histogram handle that works with `get` and `set` as part of the plotting object model.",
+    "behaviors": [
+        "`histogram(data)` creates a histogram object handle.",
+        "When you pass explicit bins through histogram-style arguments, they are treated as bin edges rather than bin centers.",
+        "Normalization modes such as count, probability, percentage, density-style variants, and cumulative forms are part of the evaluation path.",
+        "The returned histogram handle exposes properties like bin edges, counts, and normalization through `get` and accepts updates through `set` where supported.",
+        "This is the preferred histogram API for new code; use `hist` only when you intentionally want legacy center-based MATLAB semantics."
+    ],
+    "examples": [
+        {
+            "description": "Create a histogram object from data",
+            "input": "data = randn(1, 1000);\nh = histogram(data);",
+            "output": "% h is a histogram object handle"
+        },
+        {
+            "description": "Use explicit bin edges and inspect the handle",
+            "input": "data = randn(1, 500);\nedges = -3:0.25:3;\nh = histogram(data, 'BinEdges', edges);\nget(h, 'BinEdges');"
+        },
+        {
+            "description": "Apply normalization through histogram semantics",
+            "input": "data = randn(1, 500);\nh = histogram(data, 'Normalization', 'probability');\nget(h, 'Normalization')",
+            "output": "ans =\n    'probability'"
+        }
+    ],
+    "links": [
+        {
+            "label": "hist",
+            "url": "./hist"
+        },
+        {
+            "label": "bar",
+            "url": "./bar"
+        },
+        {
+            "label": "get",
+            "url": "./get"
+        },
+        {
+            "label": "set",
+            "url": "./set"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/histogram.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/histogram.rs"
+    },
+    "key": "histogram",
+    "slug": "histogram",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=histogram.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"histogram.js","sourceRoot":"","sources":["../../../src/generated/builtins/histogram.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,WAAW;IACpB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,WAAW;QACX,kBAAkB;QAClB,WAAW;QACX,sBAAsB;QACtB,kBAAkB;QAClB,uBAAuB;KACxB;IACD,SAAS,EAAE,6GAA6G;IACxH,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,QAAQ;YACR,QAAQ;SACT;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,sFAAsF;KAChG;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,sCAAsC;KAC/C;IACD,aAAa,EAAE,6RAA6R;IAC5S,WAAW,EAAE;QACX,sDAAsD;QACtD,uHAAuH;QACvH,2IAA2I;QAC3I,6JAA6J;QAC7J,qIAAqI;KACtI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,8CAA8C;YACvD,QAAQ,EAAE,kCAAkC;SAC7C;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,yGAAyG;SACnH;QACD;YACE,aAAa,EAAE,iDAAiD;YAChE,OAAO,EAAE,sGAAsG;YAC/G,QAAQ,EAAE,0BAA0B;SACrC;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;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,gEAAgE;QACzE,KAAK,EAAE,6GAA6G;KACrH;IACD,KAAK,EAAE,WAAW;IAClB,MAAM,EAAE,WAAW;IACnB,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/horzcat.js

@@ -0,0 +1,164 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "horzcat",
+    "category": "array/shape",
+    "keywords": [
+        "horzcat",
+        "horizontal concatenation",
+        "square brackets",
+        "array building",
+        "gpu"
+    ],
+    "summary": "Concatenate inputs side-by-side (dimension 2) just like MATLAB's square-bracket syntax.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Delegates to the cat builtin with dim=2; 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::horzcat::tests",
+        "integration": "builtins::array::shape::horzcat::tests::{horzcat_gpu_roundtrip,horzcat_like_gpu_from_host_inputs}"
+    },
+    "description": "`horzcat(A1, A2, …)` horizontally concatenates its inputs, matching the behaviour of MATLAB's square-bracket syntax `[A1 A2 …]`. It is the building block for row-wise array construction in RunMat.",
+    "behaviors": [
+        "Operates on numeric, logical, complex, character, string, and cell arrays with MATLAB-compatible type checking.",
+        "All inputs must have the same number of rows (dimension 1). Higher dimensions are padded with singleton sizes where necessary.",
+        "Scalars act as `1×1` building blocks, so `horzcat(1, 2, 3)` produces the row vector `[1 2 3]`.",
+        "Empty inputs participate naturally. If every operand is empty, the result is the canonical `0×0` double.",
+        "When the trailing `'like', prototype` pair is supplied, the output matches the prototype's residency (host or GPU) and numeric category.",
+        "Mixing `gpuArray` operands with host operands is an error—convert explicitly using `gpuArray` or `gather`."
+    ],
+    "examples": [
+        {
+            "description": "Concatenating matrices by columns",
+            "input": "A = [1 2; 3 4];\nB = [10 20; 30 40];\nC = horzcat(A, B)",
+            "output": "C =\n     1     2    10    20\n     3     4    30    40"
+        },
+        {
+            "description": "Building a row vector from scalars",
+            "input": "row = horzcat(1, 2, 3, 4)",
+            "output": "row = [1 2 3 4]"
+        },
+        {
+            "description": "Extending character arrays into words",
+            "input": "lhs = ['Run' ; 'GPU'];\nrhs = ['Mat' ; 'Fun'];\nwords = horzcat(lhs, rhs)",
+            "output": "words =\n    RunMat\n    GPUFun"
+        },
+        {
+            "description": "Keeping gpuArray inputs resident on the device",
+            "input": "G1 = gpuArray(rand(256, 128));\nG2 = gpuArray(rand(256, 64));\nwide = horzcat(G1, G2)"
+        },
+        {
+            "description": "Preserving empties when all inputs are empty",
+            "input": "emptyBlock = zeros(0, 3);\nresult = horzcat(emptyBlock, emptyBlock)"
+        },
+        {
+            "description": "Matching an output prototype with the `'like'` syntax",
+            "input": "proto = gpuArray.zeros(5, 1);\ncombo = horzcat(ones(5, 1), zeros(5, 1), \"like\", proto)"
+        }
+    ],
+    "faqs": [],
+    "links": [
+        {
+            "label": "`cat`",
+            "url": "./cat"
+        },
+        {
+            "label": "`vertcat`",
+            "url": "./vertcat"
+        },
+        {
+            "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/horzcat.rs",
+        "url": "crates/runmat-runtime/src/builtins/array/shape/horzcat.rs"
+    },
+    "gpu_behavior": [
+        "`horzcat` delegates to `cat(dim = 2, …)`. When the active acceleration provider implements the `cat` hook, the concatenation is executed directly on the GPU without staging data back to the CPU. Providers that lack this hook fall back to gathering the operands, concatenating on the host, and uploading the result so downstream code still sees a `gpuArray`. This mirrors MATLAB's explicit GPU workflow while keeping RunMat's auto-offload planner informed."
+    ],
+    "key": "horzcat",
+    "slug": "horzcat",
+    "categoryPath": [
+        "array",
+        "shape"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=horzcat.js.map

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

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

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

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

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

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