runmat 0.5.7-dev.3 → 0.5.7-dev.4

package/dist/generated/builtins/blkdiag.js

@@ -0,0 +1,143 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "blkdiag",
+    "category": "array/shape",
+    "keywords": [
+        "blkdiag",
+        "block diagonal",
+        "matrix assembly",
+        "sparse",
+        "gpu"
+    ],
+    "summary": "Construct block diagonal matrices from scalar, vector, matrix, sparse, complex, logical, character, or gpuArray blocks.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "RunMat gathers gpuArray inputs once, assembles the block diagonal result on the host, and uploads dense numeric, logical, or complex results back to the active provider. Sparse results remain host sparse matrices because RunMat does not yet have a sparse gpuArray representation."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": null,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::shape::blkdiag::tests",
+        "integration": "builtins::array::shape::blkdiag::tests::gpu_numeric_inputs_roundtrip_to_gpu"
+    },
+    "description": "`B = blkdiag(A1, A2, ...)` places each input block down the diagonal of a new matrix. Rows and columns are accumulated from the input blocks, and all off-block entries are filled with zeros or spaces for character arrays.",
+    "behaviors": [
+        "`blkdiag()` returns the canonical empty `0 x 0` double matrix.",
+        "Numeric scalars are treated as `1 x 1` blocks, vectors and matrices keep their two-dimensional shape, and inputs with only singleton trailing dimensions are accepted.",
+        "All-logical inputs return a logical array. Mixed logical and numeric inputs return a numeric array.",
+        "If any input is sparse and no input is character, the output is sparse when complex inputs are real-valued; dense numeric, logical, and real-valued complex blocks contribute only their nonzero entries.",
+        "If any input is complex and no input is character, the output is complex and real, logical, and sparse inputs are promoted into the real part when needed.",
+        "Sparse inputs mixed with non-real complex blocks currently return a dense complex result because RunMat does not yet have a complex sparse matrix representation.",
+        "Single-precision dense blocks preserve single dtype when all dense numeric blocks share that dtype.",
+        "Character blocks are supported when every input is a character array; off-block entries are spaces.",
+        "String arrays, cell arrays, and non-matrix higher-dimensional inputs raise errors.",
+        "gpuArray inputs can be mixed with host numeric, logical, or complex blocks. Dense numeric, logical, and complex results remain gpu-resident; sparse results remain host sparse matrices."
+    ],
+    "examples": [
+        {
+            "description": "Combining dense matrix blocks",
+            "input": "A = [1 2; 3 4];\nB = [5 6];\nC = blkdiag(A, B)",
+            "output": "C =\n     1     2     0     0\n     3     4     0     0\n     0     0     5     6"
+        },
+        {
+            "description": "Using scalar and vector blocks",
+            "input": "D = blkdiag(1, [2 3 4], 5)",
+            "output": "D =\n     1     0     0     0     0\n     0     2     3     4     0\n     0     0     0     0     5"
+        },
+        {
+            "description": "Preserving sparse output",
+            "input": "S = sparse([1 2], [1 2], [10 20], 2, 2);\nT = blkdiag(S, [0; 30])",
+            "output": "T = sparse([1 2 4], [1 2 3], [10 20 30], 4, 3)"
+        },
+        {
+            "description": "Building a complex block diagonal matrix",
+            "input": "Z = blkdiag(1 + 2i, [3; 4])"
+        },
+        {
+            "description": "Keeping all-gpuArray inputs on the GPU",
+            "input": "G1 = gpuArray([1; 2]);\nG2 = gpuArray([3 4]);\nG = blkdiag(G1, G2);\nresult = gather(G)",
+            "output": "result =\n     1     0     0\n     2     0     0\n     0     3     4"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What class does `blkdiag` return?",
+            "answer": "All-logical inputs return logical. Sparse inputs return sparse unless character input is present or a non-real complex block requires complex output. Complex inputs promote the output to complex when needed. Otherwise numeric dense output is returned."
+        },
+        {
+            "question": "Does `blkdiag` preserve sparse matrices?",
+            "answer": "Yes for real-valued sparse outputs. If any input is sparse and the output is not character or non-real complex, RunMat builds a sparse CSC result and keeps only nonzero entries from dense numeric, logical, and real-valued complex blocks. Non-real complex entries currently promote the result to dense complex because RunMat does not yet provide complex sparse storage."
+        },
+        {
+            "question": "Can I mix host arrays and gpuArray values?",
+            "answer": "Yes, for dense numeric, logical, and complex blocks. RunMat gathers gpuArray inputs, assembles the result, and uploads dense results back to the provider. Sparse results remain host sparse matrices."
+        },
+        {
+            "question": "Are character arrays supported?",
+            "answer": "Yes, when every input is a character array. The original character blocks are placed on the diagonal and spaces fill off-block positions."
+        },
+        {
+            "question": "Does `blkdiag` accept 3-D arrays?",
+            "answer": "Only inputs whose trailing dimensions are singleton are accepted. Non-matrix higher-dimensional inputs raise an error."
+        }
+    ],
+    "links": [
+        {
+            "label": "diag",
+            "url": "./diag"
+        },
+        {
+            "label": "cat",
+            "url": "./cat"
+        },
+        {
+            "label": "horzcat",
+            "url": "./horzcat"
+        },
+        {
+            "label": "vertcat",
+            "url": "./vertcat"
+        },
+        {
+            "label": "sparse",
+            "url": "./sparse"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/shape/blkdiag.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/shape/blkdiag.rs"
+    },
+    "gpu_residency": "gpuArray inputs are gathered to host for block placement, then dense numeric, logical, and complex results are uploaded back to the active provider. Sparse results remain host sparse matrices.",
+    "gpu_behavior": [
+        "`blkdiag` is GPU-aware but not fused. It materialises a fresh block diagonal array and therefore acts as a fusion sink."
+    ],
+    "key": "blkdiag",
+    "slug": "blkdiag",
+    "aliases": [],
+    "categoryPath": [
+        "array",
+        "shape"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=blkdiag.js.map

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

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

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

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

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

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

package/dist/generated/builtins/blsimpv.js

@@ -0,0 +1,72 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "blsimpv",
+    "category": "finance",
+    "keywords": [
+        "blsimpv",
+        "Black-Scholes",
+        "implied volatility",
+        "option",
+        "finance"
+    ],
+    "summary": "Compute Black-Scholes implied volatility from observed European option prices.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f64"
+        ],
+        "broadcasting": "scalar expansion over matching nonscalar inputs",
+        "notes": "`blsimpv` performs host-side root finding and gathers gpuArray inputs before solving."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 7,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::finance::black_scholes::tests"
+    },
+    "description": "`blsimpv(Price,Strike,Rate,Time,Value)` computes implied annualized volatility from an observed European option value under the Black-Scholes model.",
+    "behaviors": [
+        "Supports scalar expansion across matching nonscalar numeric inputs.",
+        "Name-value options include `Limit`, `Yield`, `Tolerance`, `Class`, and `Method`.",
+        "`Class` accepts logical values (`true` for call, `false` for put), strings, character vectors, string arrays, or cell arrays containing `call`/`put` values.",
+        "`Method` accepts `search` and `jackel2016`; the default is `jackel2016`, implemented with the same robust scalar solver but without applying caller `Limit`/`Tolerance` overrides.",
+        "Empty optional values use their documented defaults.",
+        "For `Method='search'`, if no implied volatility exists inside `[0, Limit]`, the output is `NaN`."
+    ],
+    "examples": [
+        {
+            "description": "Recover call implied volatility",
+            "input": "Volatility = blsimpv(100, 95, 0.10, 0.25, 13.6953)",
+            "output": "Volatility = 0.5000"
+        },
+        {
+            "description": "Put implied volatility with yield",
+            "input": "Volatility = blsimpv(910, 980, 0.02, 0.25, 90.4683, 'Yield', 0.025, 'Class', 'put')",
+            "output": "Volatility = 0.2500"
+        }
+    ],
+    "links": [
+        {
+            "label": "blsprice",
+            "url": "./blsprice"
+        }
+    ],
+    "source": {
+        "label": "crates/runmat-runtime/src/builtins/finance/black_scholes.rs",
+        "url": "crates/runmat-runtime/src/builtins/finance/black_scholes.rs"
+    },
+    "key": "blsimpv",
+    "slug": "blsimpv",
+    "aliases": [],
+    "categoryPath": [
+        "finance"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=blsimpv.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blsimpv.js","sourceRoot":"","sources":["../../../src/generated/builtins/blsimpv.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,SAAS;IACrB,UAAU,EAAE;QACV,SAAS;QACT,eAAe;QACf,oBAAoB;QACpB,QAAQ;QACR,SAAS;KACV;IACD,SAAS,EAAE,gFAAgF;IAC3F,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,iDAAiD;QACjE,OAAO,EAAE,uFAAuF;KACjG;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,yCAAyC;KAClD;IACD,aAAa,EAAE,sJAAsJ;IACrK,WAAW,EAAE;QACX,qEAAqE;QACrE,kFAAkF;QAClF,8JAA8J;QAC9J,oLAAoL;QACpL,sDAAsD;QACtD,kGAAkG;KACnG;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,oDAAoD;YAC7D,QAAQ,EAAE,qBAAqB;SAChC;QACD;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,qFAAqF;YAC9F,QAAQ,EAAE,qBAAqB;SAChC;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,6DAA6D;QACtE,KAAK,EAAE,6DAA6D;KACrE;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/blsprice.js

@@ -0,0 +1,71 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "blsprice",
+    "category": "finance",
+    "keywords": [
+        "blsprice",
+        "Black-Scholes",
+        "option",
+        "call",
+        "put",
+        "finance"
+    ],
+    "summary": "Compute Black-Scholes European call and put option prices.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f64"
+        ],
+        "broadcasting": "MATLAB implicit expansion",
+        "notes": "Resident real gpuArray inputs route through the provider `black_scholes_price` hook and return resident call/put gpuArray outputs. Host scalar/tensor inputs in a mixed GPU call are uploaded as temporary provider inputs; providers without the hook fall back to the host implementation."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 6,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::finance::black_scholes::tests"
+    },
+    "description": "`blsprice(Price,Strike,Rate,Time,Volatility)` computes European call and put option prices using the Black-Scholes model. An optional `Yield` argument defaults to zero.",
+    "behaviors": [
+        "Returns the call price as the single-output value and `[Call, Put]` under two-output semantics.",
+        "Each input may be scalar or an array. Inputs use MATLAB implicit expansion, so compatible nonscalar dimensions expand elementwise.",
+        "The optional `Yield` argument represents a continuously compounded dividend or foreign risk-free yield; an empty `Yield` uses the default zero yield.",
+        "Invalid financial domains and `NaN` inputs produce elementwise `NaN` outputs rather than aborting the full call."
+    ],
+    "examples": [
+        {
+            "description": "European stock option",
+            "input": "[Call, Put] = blsprice(100, 95, 0.10, 0.25, 0.50)",
+            "output": "Call = 13.6953, Put = 6.3497"
+        },
+        {
+            "description": "Stock index option with yield",
+            "input": "[Call, Put] = blsprice(910, 980, 0.02, 0.25, 0.25, 0.025)",
+            "output": "Call = 19.6863, Put = 90.4683"
+        }
+    ],
+    "links": [
+        {
+            "label": "blsimpv",
+            "url": "./blsimpv"
+        }
+    ],
+    "source": {
+        "label": "crates/runmat-runtime/src/builtins/finance/black_scholes.rs",
+        "url": "crates/runmat-runtime/src/builtins/finance/black_scholes.rs"
+    },
+    "key": "blsprice",
+    "slug": "blsprice",
+    "aliases": [],
+    "categoryPath": [
+        "finance"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=blsprice.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blsprice.js","sourceRoot":"","sources":["../../../src/generated/builtins/blsprice.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,SAAS;IACrB,UAAU,EAAE;QACV,UAAU;QACV,eAAe;QACf,QAAQ;QACR,MAAM;QACN,KAAK;QACL,SAAS;KACV;IACD,SAAS,EAAE,4DAA4D;IACvE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,2BAA2B;QAC3C,OAAO,EAAE,8RAA8R;KACxS;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,yCAAyC;KAClD;IACD,aAAa,EAAE,0KAA0K;IACzL,WAAW,EAAE;QACX,iGAAiG;QACjG,oIAAoI;QACpI,uJAAuJ;QACvJ,kHAAkH;KACnH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,uBAAuB;YACtC,OAAO,EAAE,mDAAmD;YAC5D,QAAQ,EAAE,8BAA8B;SACzC;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,2DAA2D;YACpE,QAAQ,EAAE,+BAA+B;SAC1C;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,6DAA6D;QACtE,KAAK,EAAE,6DAA6D;KACrE;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/bootstrp.js

@@ -0,0 +1,94 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "bootstrp",
+    "category": "stats/random",
+    "keywords": [
+        "bootstrp",
+        "bootstrap",
+        "resampling",
+        "statistics",
+        "weights"
+    ],
+    "summary": "Bootstrap samples and evaluate a statistic.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "GPU inputs are gathered to host before resampling and callback evaluation."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "none"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::stats::random::sampling::tests",
+        "integration": "crates/runmat-vm/tests/stats_ml.rs"
+    },
+    "description": "`bootstrp(nboot,bootfun,d)` draws `nboot` bootstrap samples with replacement from `d` and applies `bootfun` to each sample. `bootstrp(nboot,bootfun,d1,...,dN)` resamples rows jointly across nonscalar data arguments while scalar arguments are passed through unchanged. `[bootstat,bootsam] = bootstrp(...)` also returns one-based bootstrap sample indices.",
+    "behaviors": [
+        "Each row of `bootstat` contains one bootstrap replicate. Nonscalar `bootfun` outputs are flattened into one row per replicate.",
+        "A single vector input is sampled along its first nonsingleton dimension; multiple nonscalar inputs are sampled by rows and must have matching row counts.",
+        "`bootfun` can be a function handle, string function name, or empty array. Empty `bootfun` skips callback evaluation and returns an empty `bootstat` with `bootsam` available as the second output.",
+        "`\"Weights\",w` samples rows proportionally to nonnegative weights with at least one positive value.",
+        "`\"Options\",opts` accepts a statset-style options struct for compatibility. Parallel execution options are accepted but currently evaluated serially.",
+        "Numeric, logical, string, char, and cell data arrays are supported for sampling; `bootfun` must return numeric or logical values."
+    ],
+    "examples": [
+        {
+            "description": "Bootstrap a mean",
+            "input": "b = bootstrp(1000, @mean, x)"
+        },
+        {
+            "description": "Return sample indices",
+            "input": "[b,bootsam] = bootstrp(200, @median, x)"
+        },
+        {
+            "description": "Bootstrap a two-input statistic",
+            "input": "b = bootstrp(500, @corr, x, y)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does bootstrp use the global random stream?",
+            "answer": "Yes. It uses RunMat's global random stream, like datasample and randsample."
+        },
+        {
+            "question": "Does bootstrp run callbacks in parallel?",
+            "answer": "No. RunMat accepts the Options name-value for MATLAB compatibility, but callback evaluation is currently serial."
+        }
+    ],
+    "links": [
+        {
+            "label": "datasample",
+            "url": "./datasample"
+        },
+        {
+            "label": "randsample",
+            "url": "./randsample"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/stats/random/sampling.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/stats/random/sampling.rs"
+    },
+    "key": "bootstrp",
+    "slug": "bootstrp",
+    "aliases": [],
+    "categoryPath": [
+        "stats",
+        "random"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=bootstrp.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrp.js","sourceRoot":"","sources":["../../../src/generated/builtins/bootstrp.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,cAAc;IAC1B,UAAU,EAAE;QACV,UAAU;QACV,WAAW;QACX,YAAY;QACZ,YAAY;QACZ,SAAS;KACV;IACD,SAAS,EAAE,6CAA6C;IACxD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,4EAA4E;KACtF;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,MAAM;KACpB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,0CAA0C;QAClD,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,mWAAmW;IAClX,WAAW,EAAE;QACX,gIAAgI;QAChI,2JAA2J;QAC3J,oMAAoM;QACpM,sGAAsG;QACtG,wJAAwJ;QACxJ,mIAAmI;KACpI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,kBAAkB;YACjC,OAAO,EAAE,8BAA8B;SACxC;QACD;YACE,aAAa,EAAE,uBAAuB;YACtC,OAAO,EAAE,yCAAyC;SACnD;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,gCAAgC;SAC1C;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,6EAA6E;SACxF;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,kHAAkH;SAC7H;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,cAAc;SACtB;QACD;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,cAAc;SACtB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,4GAA4G;KACpH;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/bounds.js

@@ -0,0 +1,96 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "bounds",
+    "category": "math/reduction",
+    "keywords": [
+        "bounds",
+        "minimum",
+        "maximum",
+        "reduction",
+        "omitnan"
+    ],
+    "summary": "Return smallest and largest elements in MATLAB and RunMat.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": true,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Delegates to the existing `min` and `max` reduction engines, including their GPU fallbacks and host execution paths."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::reduction::bounds::tests",
+        "integration": null
+    },
+    "description": "`bounds(A)` returns the smallest and largest values from each slice of `A` along the first non-singleton dimension.",
+    "behaviors": [
+        "`[S,L] = bounds(A)` returns the same values as `min(A)` and `max(A)` using the default dimension.",
+        "`bounds(A,dim)` and `bounds(A,vecdim)` reduce along explicit dimensions.",
+        "`bounds(A,'all')` reduces all elements and returns scalar lower and upper bounds.",
+        "`bounds` omits NaN values by default, matching MATLAB. Pass `'includenan'` to propagate NaN values consistently with `min` and `max`.",
+        "Logical, integer, real, complex, scalar, vector, matrix, N-D, and GPU tensor inputs follow the behavior of the underlying `min` and `max` builtins."
+    ],
+    "examples": [
+        {
+            "description": "Column-wise bounds",
+            "input": "A = [3 4; 1 2];\n[S,L] = bounds(A)",
+            "output": "S = [1 2]\nL = [3 4]"
+        },
+        {
+            "description": "Bounds across all elements while ignoring NaN by default",
+            "input": "A = [NaN 3; -1 5];\n[S,L] = bounds(A,'all')",
+            "output": "S = -1\nL = 5"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How many outputs does `bounds` return?",
+            "answer": "It returns two outputs: the smallest values and the largest values. RunMat pads additional requested outputs with zero, matching the runtime's multi-output convention."
+        },
+        {
+            "question": "Does `bounds` have separate GPU kernels?",
+            "answer": "No. It composes `min` and `max`, so it inherits their GPU support and host fallback behavior."
+        }
+    ],
+    "links": [
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "maxk",
+            "url": "./maxk"
+        },
+        {
+            "label": "mink",
+            "url": "./mink"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/reduction/bounds.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/bounds.rs"
+    },
+    "key": "bounds",
+    "slug": "bounds",
+    "aliases": [],
+    "categoryPath": [
+        "math",
+        "reduction"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=bounds.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bounds.js","sourceRoot":"","sources":["../../../src/generated/builtins/bounds.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,gBAAgB;IAC5B,UAAU,EAAE;QACV,QAAQ;QACR,SAAS;QACT,SAAS;QACT,WAAW;QACX,SAAS;KACV;IACD,SAAS,EAAE,4DAA4D;IACvE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,IAAI;QACjB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,sHAAsH;KAChI;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,0CAA0C;QAClD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,qHAAqH;IACpI,WAAW,EAAE;QACX,mGAAmG;QACnG,0EAA0E;QAC1E,mFAAmF;QACnF,uIAAuI;QACvI,qJAAqJ;KACtJ;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,oBAAoB;YACnC,OAAO,EAAE,oCAAoC;YAC7C,QAAQ,EAAE,sBAAsB;SACjC;QACD;YACE,aAAa,EAAE,0DAA0D;YACzE,OAAO,EAAE,6CAA6C;YACtD,QAAQ,EAAE,eAAe;SAC1B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,yKAAyK;SACpL;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,+FAA+F;SAC1G;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,4GAA4G;KACpH;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,WAAW;KACZ;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/boxplot.js

@@ -0,0 +1,64 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "boxplot",
+    "category": "stats/summary",
+    "keywords": [
+        "boxplot",
+        "box plot",
+        "statistics",
+        "quartile",
+        "outlier",
+        "visualization"
+    ],
+    "summary": "Visualize sample quartiles, whiskers, medians, and outliers.",
+    "signatures": [
+        "boxplot(x)",
+        "boxplot(x,g)",
+        "boxplot(ax,___)",
+        "boxplot(___,Name,Value)",
+        "h = boxplot(___)"
+    ],
+    "description": "`boxplot(x)` plots one box for a vector and one box per matrix column. `boxplot(x,g)` groups vector data by numeric, text, cell, or categorical grouping variables. With an output, RunMat returns a row vector of graphics handles for the line and scatter primitives used to draw the boxes.",
+    "notes": [
+        "NaN data values are omitted from quartile, median, whisker, and outlier calculations.",
+        "Quartiles use linear interpolation over sorted finite observations. Whiskers extend to the most extreme observations within `Whisker` times the interquartile range.",
+        "Grouping variables can be numeric vectors, string arrays, character matrices, cell arrays of scalar group labels, categorical arrays, or cell arrays of grouping vectors. Missing group labels are omitted.",
+        "`DataLim`, `ExtremeMode`, and `Jitter` control outlier display. `ExtremeMode` clips or compresses outlier markers outside the data limits, and traditional plots default to no jitter.",
+        "Recognized options include `Labels`, `GroupOrder`, `Orientation`, `Positions`, `Widths`, `Whisker`, `Colors`, `Symbol`, `OutlierSize`, `PlotStyle`, `BoxStyle`, `MedianStyle`, `Notch`, `DataLim`, `ExtremeMode`, `Jitter`, `LabelOrientation`, `LabelVerbosity`, and factor display validation options.",
+        "`BoxStyle`, `MedianStyle`, `Notch`, and factor display layout options are accepted for compatibility; the current renderer draws an outline box, median line, whiskers, caps, and optional outlier markers."
+    ],
+    "examples": [
+        {
+            "description": "Plot one box for each matrix column",
+            "input": "boxplot([1 10; 2 20; 3 30; 4 40])"
+        },
+        {
+            "description": "Plot grouped vector data with labels",
+            "input": "h = boxplot([1;2;10;20], {'A';'A';'B';'B'}, 'Labels', {'First','Second'})"
+        },
+        {
+            "description": "Plot horizontal boxes with a custom whisker length",
+            "input": "boxplot([1;2;3;100], 'Orientation', 'horizontal', 'Whisker', 1)"
+        }
+    ],
+    "links": [
+        {
+            "label": "ecdf",
+            "url": "./ecdf"
+        },
+        {
+            "label": "histogram",
+            "url": "./histogram"
+        }
+    ],
+    "key": "boxplot",
+    "slug": "boxplot",
+    "aliases": [],
+    "categoryPath": [
+        "stats",
+        "summary"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=boxplot.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boxplot.js","sourceRoot":"","sources":["../../../src/generated/builtins/boxplot.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,SAAS;QACT,UAAU;QACV,YAAY;QACZ,UAAU;QACV,SAAS;QACT,eAAe;KAChB;IACD,SAAS,EAAE,8DAA8D;IACzE,YAAY,EAAE;QACZ,YAAY;QACZ,cAAc;QACd,iBAAiB;QACjB,yBAAyB;QACzB,kBAAkB;KACnB;IACD,aAAa,EAAE,iSAAiS;IAChT,OAAO,EAAE;QACP,uFAAuF;QACvF,sKAAsK;QACtK,6MAA6M;QAC7M,wLAAwL;QACxL,0SAA0S;QAC1S,6MAA6M;KAC9M;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,mCAAmC;SAC7C;QACD;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,2EAA2E;SACrF;QACD;YACE,aAAa,EAAE,oDAAoD;YACnE,OAAO,EAAE,iEAAiE;SAC3E;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;KACF;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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