runmat 0.3.5 → 0.4.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"power.js","sourceRoot":"","sources":["../../../src/generated/builtins/power.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,kBAAkB;IAC9B,UAAU,EAAE;QACV,OAAO;QACP,oBAAoB;QACpB,WAAW;QACX,KAAK;QACL,cAAc;KACf;IACD,SAAS,EAAE,6GAA6G;IACxH,YAAY,EAAE;QACZ,sDAAsD;KACvD;IACD,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,yKAAyK;KACnL;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,iEAAiE;QACzE,aAAa,EAAE,mEAAmE;QAClF,KAAK,EAAE,qEAAqE;QAC5E,MAAM,EAAE,+EAA+E;QACvF,UAAU,EAAE,qEAAqE;QACjF,cAAc,EAAE,+EAA+E;KAChG;IACD,aAAa,EAAE,kPAAkP;IACjQ,WAAW,EAAE;QACX,+JAA+J;QAC/J,0IAA0I;QAC1I,4KAA4K;QAC5K,0EAA0E;QAC1E,0IAA0I;KAC3I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2BAA2B;YAC1C,OAAO,EAAE,iBAAiB;YAC1B,QAAQ,EAAE,QAAQ;SACnB;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,sCAAsC;YAC/C,QAAQ,EAAE,6CAA6C;SACxD;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,qEAAqE;YAC9E,QAAQ,EAAE,sEAAsE;SACjF;QACD;YACE,aAAa,EAAE,6CAA6C;YAC5D,OAAO,EAAE,oCAAoC;YAC7C,QAAQ,EAAE,6DAA6D;SACxE;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,gJAAgJ;YACzJ,QAAQ,EAAE,0FAA0F;SACrG;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,yBAAyB;YAClC,QAAQ,EAAE,0BAA0B;SACrC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,4HAA4H;SACvI;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,uKAAuK;SAClL;QACD;YACE,UAAU,EAAE,+BAA+B;YAC3C,QAAQ,EAAE,2FAA2F;SACtG;QACD;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,kPAAkP;SAC7P;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,mLAAmL;SAC9L;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,iIAAiI;SAC5I;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;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,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,gEAAgE;QACzE,KAAK,EAAE,6GAA6G;KACrH;IACD,eAAe,EAAE,saAAsa;IACvb,cAAc,EAAE;QACd,wOAAwO;QACxO,+IAA+I;QAC/I,gNAAgN;KACjN;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,cAAc,EAAE;QACd,MAAM;QACN,aAAa;KACd;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

@@ -0,0 +1,192 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "prod",
+    "category": "math/reduction",
+    "keywords": [
+        "prod",
+        "product",
+        "reduction",
+        "omitnan",
+        "gpu"
+    ],
+    "summary": "Multiply 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": "Prefers provider reduce_prod_dim / reduce_prod hooks; falls back to the host for omitnan, multi-axis, or class-prototype requests."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": true,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::reduction::prod::tests",
+        "integration": "builtins::math::reduction::prod::tests::prod_gpu_provider_roundtrip"
+    },
+    "description": "`prod(X)` multiplies the elements of scalars, vectors, matrices, and higher-dimensional tensors. When no dimension is supplied, the reduction runs along the first non-singleton dimension.",
+    "behaviors": [
+        "`prod(X)` on an `m × n` matrix returns a row vector (`1 × n`) with column-wise products.",
+        "`prod(X, 2)` returns a column vector (`m × 1`) containing row-wise products.",
+        "`prod(X, dims)` accepts a vector of dimensions (for example `[1 3]`) and collapses each listed axis while leaving the others untouched.",
+        "`prod(X, 'all')` flattens every dimension into a single scalar product.",
+        "Logical inputs are promoted to double precision (`true → 1.0`, `false → 0.0`) unless you request `'native'` or `'like'` output classes.",
+        "`prod(___, 'omitnan')` ignores `NaN` values; if every element in the slice is `NaN`, the result becomes `1`, the multiplicative identity.",
+        "`prod(___, 'includenan')` (default) propagates `NaN` whenever a `NaN` appears in that slice.",
+        "`prod(___, outtype)` accepts `'double'`, `'default'`, or `'native'` to control the output class.",
+        "`prod(___, 'like', prototype)` matches the numeric class and residency of `prototype` when supported by the active provider.",
+        "Empty inputs or reductions along dimensions with size `0` return ones that follow MATLAB shape semantics."
+    ],
+    "examples": [
+        {
+            "description": "Multiplying the elements of a matrix",
+            "input": "A = [1 2 3; 4 5 6];\ncolProd = prod(A);\nrowProd = prod(A, 2)",
+            "output": "colProd = [4 10 18];\nrowProd = [6; 120]"
+        },
+        {
+            "description": "Multiplying across multiple dimensions",
+            "input": "B = reshape(1:24, [3 4 2]);\nprod13 = prod(B, [1 3])",
+            "output": "prod13 =\n     16380   587520  4021920  16030080"
+        },
+        {
+            "description": "Multiplying with NaN values ignored",
+            "input": "values = [2 NaN 4];\ncleanProd = prod(values, 'omitnan')",
+            "output": "cleanProd = 8"
+        },
+        {
+            "description": "Multiplying on the GPU and matching an existing prototype",
+            "input": "G = gpuArray(ones(1024, 1024) + 0.01);\nproto = gpuArray(zeros(1, 1));\ngpuResult = prod(G, 'like', proto);\nresult = gather(gpuResult)"
+        },
+        {
+            "description": "Multiplying all elements of an array into a scalar",
+            "input": "P = prod(1:10, 'all')",
+            "output": "P = 3628800"
+        },
+        {
+            "description": "Multiplying with native output type",
+            "input": "ints = int16([2 3 4]);\nnativeProd = prod(ints, 'native')",
+            "output": "nativeProd = int16(24)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I use the `prod` function?",
+            "answer": "Use `prod` whenever you need multiplicative reductions: geometric means, determinant-like products, or scaling chains of factors."
+        },
+        {
+            "question": "Does `prod` produce double arrays by default?",
+            "answer": "Yes. Unless you request `'native'` or provide a `'like'` prototype, the result is a dense double-precision array on the host."
+        },
+        {
+            "question": "What does `prod(A)` return?",
+            "answer": "If you call `prod(A)` where `A` is an array, the result is a new array of the same shape as `A` with products taken along the first non-singleton dimension."
+        },
+        {
+            "question": "How do I compute the product of a specific dimension?",
+            "answer": "Pass the dimension as the second argument (`prod(A, 2)` for row-wise products) or provide a dimension vector (`prod(A, [1 3])`) to collapse multiple axes at once."
+        },
+        {
+            "question": "What happens if all elements are `NaN` and I request `'omitnan'`?",
+            "answer": "The result becomes `1`, matching MATLAB's multiplicative identity semantics for empty slices."
+        },
+        {
+            "question": "Does `prod` preserve integer classes?",
+            "answer": "Only when you explicitly request `'native'` or `'like'`. Otherwise, integers are promoted to double precision so you do not have to manage overflow manually."
+        }
+    ],
+    "links": [
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "cumprod",
+            "url": "./cumprod"
+        },
+        {
+            "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": "cumsum",
+            "url": "./cumsum"
+        },
+        {
+            "label": "diff",
+            "url": "./diff"
+        },
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "median",
+            "url": "./median"
+        },
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "nnz",
+            "url": "./nnz"
+        },
+        {
+            "label": "std",
+            "url": "./std"
+        },
+        {
+            "label": "var",
+            "url": "./var"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/reduction/prod.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/prod.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` yourself in RunMat. The fusion planner keeps residency on the GPU for fused expressions, and reduction kernels execute on the device whenever the provider exposes the necessary hooks. To match MathWorks MATLAB behaviour—or to bootstrap GPU residency explicitly—you can still create GPU arrays manually.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active, tensors that already reside on the GPU remain on the device. The runtime calls `reduce_prod_dim` (or `reduce_prod` for whole-array products) on the active provider when available. Requests that require `'omitnan'`, multi-axis reductions, or class coercions fall back to the host implementation, compute the correct MATLAB result, and re-upload only when a `'like'` prototype demands GPU residency."
+    ],
+    "key": "prod",
+    "slug": "prod",
+    "categoryPath": [
+        "math",
+        "reduction"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=prod.js.map

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

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

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

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

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

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

package/dist/generated/builtins/pwd.js

@@ -0,0 +1,190 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "pwd",
+    "category": "io/repl_fs",
+    "keywords": [
+        "pwd",
+        "current directory",
+        "working folder",
+        "present working directory"
+    ],
+    "summary": "Return the absolute path to the folder where RunMat is currently executing.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/pwd.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs entirely on the host CPU. No GPU kernels are launched and no provider hooks are required."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::io::repl_fs::pwd::tests",
+        "integration": "builtins::io::repl_fs::pwd::tests::pwd_reflects_directory_changes"
+    },
+    "description": "`pwd` returns the absolute path of the folder where RunMat is executing. The result is a character row vector (`1×N`) so existing MATLAB code that expects traditional character output keeps working.",
+    "behaviors": [
+        "Always returns the current working folder of the RunMat process.",
+        "Output is a character vector using the platform-native path separators.",
+        "Does not accept any input arguments; if arguments are provided, MATLAB raises an error. RunMat follows the same rule by reporting `pwd: too many input arguments`.",
+        "Errors if RunMat is unable to query the current folder from the operating system.",
+        "Designed to cooperate with `cd` so workflows like `start = pwd; cd(\"subfolder\"); ...; cd(start);` behave exactly as they do in MATLAB."
+    ],
+    "examples": [
+        {
+            "description": "Show The Current Working Folder",
+            "input": "current = pwd;\ndisp(current)",
+            "output": "/"
+        },
+        {
+            "description": "Capture The Folder Before Changing Directories",
+            "input": "startDir = pwd;\nif ~exist(\"results\", \"dir\")\n    mkdir(\"results\");\nend\ncd(\"results\");\n% ... produce artifacts in results/ ...\ncd(startDir)",
+            "output": "% Restores the original folder after work completes"
+        },
+        {
+            "description": "Combine `pwd` With `cd` To Print Relative Paths",
+            "input": "old = cd(\"..\");\nfprintf(\"Now working in: %s\\n\", pwd);\ncd(old)",
+            "output": "% Prints the absolute path to the parent directory, then returns to the old folder\n% For example:\n%   Now working in: /home"
+        },
+        {
+            "description": "Confirm The Folder Inside Scripts",
+            "input": "fprintf(\"Script started in %s\\n\", pwd)",
+            "output": "% Example output:\n%   Script started in /"
+        },
+        {
+            "description": "Log The Working Folder Together With Results",
+            "input": "logFile = \"run.log\";\nfid = fopen(logFile, \"w\");\nfprintf(fid, \"Working folder: %s\\n\", pwd);\nfclose(fid)",
+            "output": "% The log file contains a line such as:\n%   Working folder: /"
+        },
+        {
+            "description": "Handle Errors When The Working Folder Is Unavailable",
+            "input": "try\n    location = pwd;\ncatch err\n    disp(err.message);\nend",
+            "output": "% Displays a descriptive error message if RunMat cannot query the folder,\n% for example:\n%   pwd: unable to determine current directory (Permission denied)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why does `pwd` return a character vector instead of a string?",
+            "answer": "MATLAB historically returns character vectors for `pwd`. RunMat mirrors that behavior so existing code keeps working. Use `string(pwd)` if you prefer string scalars."
+        },
+        {
+            "question": "Does `pwd` reflect changes made with `cd`?",
+            "answer": "Yes. Any successful `cd` call immediately affects what `pwd` returns, matching MATLAB's semantics."
+        },
+        {
+            "question": "Can `pwd` fail?",
+            "answer": "It is rare, but the operating system can prevent the process from querying the current folder. In that case RunMat raises an error that includes the OS reason."
+        },
+        {
+            "question": "Does `pwd` normalize the path?",
+            "answer": "RunMat returns the operating-system path exactly as reported, just like MATLAB."
+        },
+        {
+            "question": "Is `pwd` safe to call from GPU-heavy scripts?",
+            "answer": "Absolutely. The builtin does not allocate GPU memory or trigger device operations."
+        }
+    ],
+    "links": [
+        {
+            "label": "cd",
+            "url": "./cd"
+        },
+        {
+            "label": "addpath",
+            "url": "./addpath"
+        },
+        {
+            "label": "copyfile",
+            "url": "./copyfile"
+        },
+        {
+            "label": "delete",
+            "url": "./delete"
+        },
+        {
+            "label": "dir",
+            "url": "./dir"
+        },
+        {
+            "label": "exist",
+            "url": "./exist"
+        },
+        {
+            "label": "fullfile",
+            "url": "./fullfile"
+        },
+        {
+            "label": "genpath",
+            "url": "./genpath"
+        },
+        {
+            "label": "getenv",
+            "url": "./getenv"
+        },
+        {
+            "label": "ls",
+            "url": "./ls"
+        },
+        {
+            "label": "mkdir",
+            "url": "./mkdir"
+        },
+        {
+            "label": "movefile",
+            "url": "./movefile"
+        },
+        {
+            "label": "path",
+            "url": "./path"
+        },
+        {
+            "label": "rmdir",
+            "url": "./rmdir"
+        },
+        {
+            "label": "rmpath",
+            "url": "./rmpath"
+        },
+        {
+            "label": "savepath",
+            "url": "./savepath"
+        },
+        {
+            "label": "setenv",
+            "url": "./setenv"
+        },
+        {
+            "label": "tempdir",
+            "url": "./tempdir"
+        },
+        {
+            "label": "tempname",
+            "url": "./tempname"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/io/repl_fs/pwd.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/repl_fs/pwd.rs"
+    },
+    "gpu_residency": "No. `pwd` always operates on the CPU. Even in scripts that perform extensive GPU computation, you can call `pwd` at any time to confirm the working folder without affecting GPU residency or triggering device transfers.",
+    "gpu_behavior": [
+        "`pwd` never runs on the GPU. It performs a host-side query of the process working directory and returns the result as a character vector. The builtin registers a CPU-only GPU spec with `ResidencyPolicy::GatherImmediately`, ensuring fusion plans always surface the path on the host. Because there are no inputs, nothing is gathered from device memory and acceleration providers do not need to implement any hooks for this builtin."
+    ],
+    "key": "pwd",
+    "slug": "pwd",
+    "categoryPath": [
+        "io",
+        "repl_fs"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=pwd.js.map

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

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

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

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

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

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

@@ -0,0 +1,154 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "qr",
+    "category": "math/linalg/factor",
+    "keywords": [
+        "qr",
+        "factorization",
+        "decomposition",
+        "householder",
+        "pivoting"
+    ],
+    "summary": "QR factorization with optional column pivoting and economy-size outputs.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Bundled WGPU provider reuses the host QR and re-uploads outputs; other providers fall back to the same host path automatically."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::linalg::factor::qr::tests",
+        "integration": "builtins::math::linalg::factor::qr::tests::qr_three_outputs_reconstructs_input"
+    },
+    "description": "`qr(A)` computes an orthogonal (or unitary)–upper-triangular factorization of a real or complex matrix `A`. It matches MATLAB’s dense semantics, supporting full-size, economy-size, and column-pivoted variants.",
+    "behaviors": [
+        "Single output: `R = qr(A)` returns the upper-triangular (or upper-trapezoidal) factor. Column pivoting is applied implicitly for numerical stability.",
+        "Two outputs: `[Q, R] = qr(A)` yields the orthonormal/unitary factor `Q` and the upper-triangular `R` such that `Q * R = A * E`, where `E` is the column permutation matrix selected during factorization. When you omit `E`, the columns of `R` already appear in that permuted order.",
+        "Three outputs: `[Q, R, E] = qr(A)` additionally returns the column permutation so that `A * E = Q * R`. Use the `'vector'` option to receive a pivot vector instead of a permutation matrix.",
+        "Economy size: `qr(A, 0)` or `qr(A, 'econ')` returns the reduced-size factors, mirroring MATLAB’s behaviour: when `m ≥ n`, `Q` is `m × n` and `R` is `n × n`. For wide matrices (`m < n`) the economy form equals the full form.",
+        "Logical inputs are promoted to double precision. Scalars and vectors are treated as 1-D or 2-D dense arrays."
+    ],
+    "examples": [
+        {
+            "description": "Computing the full QR factorization of a square matrix",
+            "input": "A = [12 -51 4; 6 167 -68; -4 24 -41];\n[Q, R] = qr(A)"
+        },
+        {
+            "description": "Obtaining orthonormal Q and upper-triangular R for a tall matrix",
+            "input": "A = [1 2; 3 4; 5 6];\n[Q, R] = qr(A)"
+        },
+        {
+            "description": "Working with column pivoting when requesting three outputs",
+            "input": "A = [1 1 0; 1 0 1; 0 1 1];\n[Q, R, E] = qr(A)"
+        },
+        {
+            "description": "Using economy-size QR to reduce memory footprint",
+            "input": "A = randn(1000, 20);\n[Q, R] = qr(A, 0)"
+        },
+        {
+            "description": "Receiving the permutation vector instead of a matrix",
+            "input": "A = magic(4);\n[Q, R, p] = qr(A, 'vector')"
+        },
+        {
+            "description": "Running QR on a gpuArray input (with automatic fallback)",
+            "input": "G = gpuArray(rand(256, 64));\n[Q, R] = qr(G, 'econ');\nclass(Q)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `qr(A)` always perform column pivoting?",
+            "answer": "Yes. MATLAB switched to pivoted QR for the single-output form many releases ago; RunMat mirrors that behaviour for improved numerical stability."
+        },
+        {
+            "question": "How do I request the reduced (economy) factors?",
+            "answer": "Pass `0`, `'0'`, or `'econ'` as the second argument. For example, `[Q,R] = qr(A,0)` or `[Q,R] = qr(A,'econ')`."
+        },
+        {
+            "question": "How can I obtain the permutation vector instead of a matrix?",
+            "answer": "Add the option `'vector'`, e.g., `[Q,R,p] = qr(A,'vector')`. When you also request economy size, use `[Q,R,p] = qr(A,'econ','vector')`."
+        },
+        {
+            "question": "Are complex matrices supported?",
+            "answer": "Yes. Inputs of type complex double produce complex orthonormal factors using complex Householder reflectors."
+        },
+        {
+            "question": "What precision do the returned factors use?",
+            "answer": "The builtin always produces double-precision (or complex double) outputs, matching MATLAB’s dense QR behaviour."
+        },
+        {
+            "question": "Can I call `qr` on logical arrays?",
+            "answer": "Yes. Logical inputs are converted to double precision before factorisation."
+        },
+        {
+            "question": "What happens if I pass more than two option arguments?",
+            "answer": "The builtin raises a MATLAB-compatible error (`qr: too many option arguments`). Only one size option and one permutation option are accepted."
+        },
+        {
+            "question": "Do gpuArray outputs stay on the device?",
+            "answer": "Yes when an acceleration provider exposes the QR hook; the bundled WGPU backend does so by staging through the host implementation and re-uploading the factors. Otherwise RunMat gathers the data to the host, factors it there, and uploads the results back automatically."
+        },
+        {
+            "question": "How can I verify the factorisation?",
+            "answer": "Check that `Q'*Q` is (approximately) the identity matrix and that `Q*R` equals `A*E`. For vector permutations, `A(:,p)` reproduces the pivoted columns."
+        }
+    ],
+    "links": [
+        {
+            "label": "lu",
+            "url": "./lu"
+        },
+        {
+            "label": "chol",
+            "url": "./chol"
+        },
+        {
+            "label": "svd",
+            "url": "./svd"
+        },
+        {
+            "label": "det",
+            "url": "./det"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "eig",
+            "url": "./eig"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/linalg/factor/qr.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/linalg/factor/qr.rs"
+    },
+    "gpu_behavior": [
+        "When the active acceleration provider exposes the dedicated QR hook (the bundled WGPU backend does), RunMat stages the input through the provider, performs the factorisation via the runtime implementation, and re-uploads all outputs so they remain resident as `gpuTensor` handles.",
+        "If no provider hook is present, RunMat gathers the input to the host, performs the CPU factorisation, and leaves the outputs on the host until an explicit `gpuArray` request."
+    ],
+    "key": "qr",
+    "slug": "qr",
+    "categoryPath": [
+        "math",
+        "linalg",
+        "factor"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=qr.js.map

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

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

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

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

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

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