runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/conv2.js

@@ -0,0 +1,152 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "conv2",
+    "category": "math/signal",
+    "keywords": [
+        "conv2",
+        "2d convolution",
+        "image processing",
+        "filtering",
+        "gpu",
+        "same",
+        "valid"
+    ],
+    "summary": "Two-dimensional convolution with MATLAB-compatible padding modes.",
+    "references": [
+        "title: \"MATLAB conv2 documentation\""
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "When the active provider lacks a conv2d hook RunMat gathers inputs to the host and executes the CPU path."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::signal::conv2::tests",
+        "integration": [
+            "builtins::math::signal::conv2::tests::conv2_gpu_roundtrip_matches_cpu",
+            "builtins::math::signal::conv2::tests::conv2_wgpu_fallback_matches_cpu"
+        ]
+    },
+    "description": "`conv2` performs two-dimensional linear convolution. By default it returns the *full* convolution (`size(A) + size(B) - 1`), but it can also return the *same* or *valid* regions so results match MATLAB exactly. The builtin accepts real or complex inputs, logical arrays (promoted to double), and the separable form `conv2(hcol, hrow, A)` that is common in image processing pipelines.",
+    "behaviors": [
+        "`conv2(A, B)` returns the full 2-D convolution of `A` and `B`.",
+        "`conv2(A, B, 'same')` slices the central part of the full convolution so the output matches the shape of `A`.",
+        "For even-sized kernels with `'same'`, alignment follows MATLAB's top-left convention in each even dimension.",
+        "`conv2(A, B, 'valid')` returns only those points where `B` overlaps `A` completely.",
+        "`conv2(hcol, hrow, A)` is syntactic sugar for `conv2(hcol(:) * hrow(:)', A)`.",
+        "Scalars are treated as `1×1` matrices and preserve the orientation of the other input.",
+        "Empty inputs follow MATLAB’s rules: `conv2([], X)` and `conv2(X, [])` return empty matrices (or zero-sized slices for `'same'`).",
+        "Logical inputs are promoted to double precision before computation; complex inputs preserve their imaginary part throughout the convolution."
+    ],
+    "examples": [
+        {
+            "description": "Smoothing an image patch with a 3×3 averaging kernel",
+            "input": "A = [1 2 3; 4 5 6; 7 8 9];\nh = ones(3) / 9;\nsmoothed = conv2(A, h, 'same')",
+            "output": "smoothed =\n    1.3333    2.3333    1.7778\n    3.0000    5.0000    3.6667\n    2.6667    4.3333    3.1111"
+        },
+        {
+            "description": "Computing the full convolution of two small kernels",
+            "input": "K1 = [1 2; 3 4];\nK2 = [1 1; 1 1];\nC = conv2(K1, K2)",
+            "output": "C =\n     1     3     2\n     4    10     6\n     3     7     4"
+        },
+        {
+            "description": "Extracting the same-sized result to preserve dimensions",
+            "input": "edge = conv2([1 2 3; 4 5 6; 7 8 9], [1 0 -1; 1 0 -1; 1 0 -1], 'same')",
+            "output": "edge =\n    -7    -4     7\n   -15    -6    15\n   -13    -4    13"
+        },
+        {
+            "description": "Valid convolution for sliding-window statistics",
+            "input": "block = magic(4);\nkernel = ones(2);\nvalid = conv2(block, kernel, 'valid')",
+            "output": "valid =\n    34    26    34\n    32    34    36\n    34    42    34"
+        },
+        {
+            "description": "Using the separable form with column and row vectors",
+            "input": "hcol = [1; 2; 1];\nhrow = [1 0 -1];\nA = [3 4 5; 6 7 8; 9 10 11];\ngx = conv2(hcol, hrow, A, 'same')",
+            "output": "gx =\n    27    -6   -27\n    28    -8   -28\n    15    -6   -15"
+        },
+        {
+            "description": "Convolving gpuArray inputs with transparent fallbacks",
+            "input": "G = gpuArray(rand(128, 128));\nH = gpuArray([1 2 1; 0 0 0; -1 -2 -1]);\ngx = conv2(G, H, 'same');\nresult = gather(gx)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `conv2` support the three MATLAB shape modes?",
+            "answer": "Yes. Pass `'full'`, `'same'`, or `'valid'` as the final argument and RunMat will mirror MATLAB’s output sizes and edge handling precisely."
+        },
+        {
+            "question": "How do I use the separable form?",
+            "answer": "Call `conv2(hcol, hrow, A)` (optionally with a shape argument). RunMat converts the vectors into an outer-product kernel internally so it behaves exactly like MATLAB."
+        },
+        {
+            "question": "What happens if one input is empty?",
+            "answer": "An empty input produces an empty output (or a zero-sized slice for `'same'`). This follows MATLAB’s behaviour and avoids surprising dimension growth."
+        },
+        {
+            "question": "Do logical inputs work?",
+            "answer": "Yes. Logical arrays are promoted to double precision before convolution so the result is numeric."
+        },
+        {
+            "question": "Will the result stay on the GPU?",
+            "answer": "If the active provider exposes the `conv2d` hook the result stays device-resident. Otherwise RunMat falls back to the CPU path and returns a host tensor; this fallback is documented so providers can add native kernels without breaking compatibility."
+        }
+    ],
+    "links": [
+        {
+            "label": "conv",
+            "url": "./conv"
+        },
+        {
+            "label": "filter2",
+            "url": "./filter2"
+        },
+        {
+            "label": "imfilter",
+            "url": "./imfilter"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "deconv",
+            "url": "./deconv"
+        },
+        {
+            "label": "filter",
+            "url": "./filter"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/signal/conv2.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/signal/conv2.rs"
+    },
+    "gpu_behavior": [
+        "RunMat Accelerate keeps tensors on the GPU when the active provider implements a `conv2d` hook (the in-process provider uses the host implementation and returns a GPU handle; the WGPU backend will adopt a native kernel). When the hook is unavailable, RunMat gathers GPU inputs to the host, performs the convolution on the CPU, and returns a host tensor. Documentation and the GPU metadata make this fallback explicit so providers can add native implementations without changing this builtin."
+    ],
+    "key": "conv2",
+    "slug": "conv2",
+    "categoryPath": [
+        "math",
+        "signal"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=conv2.js.map

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

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

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

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

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

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

package/dist/generated/builtins/copyfile.js

@@ -0,0 +1,213 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "copyfile",
+    "category": "io/repl_fs",
+    "keywords": [
+        "copyfile",
+        "copy file",
+        "copy folder",
+        "filesystem",
+        "status",
+        "message",
+        "messageid",
+        "force",
+        "overwrite"
+    ],
+    "summary": "Copy files or folders with MATLAB-compatible status, diagnostic message, and message ID outputs.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/copyfile.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs entirely on the host CPU. When path arguments live on the GPU, RunMat gathers them to host memory before touching the filesystem."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::io::repl_fs::copyfile::tests",
+        "integration": "builtins::io::repl_fs::copyfile::tests::copyfile_copies_folder_tree"
+    },
+    "description": "`copyfile` duplicates files and folders. It mirrors MATLAB's behavior by returning a numeric status plus optional diagnostic text instead of throwing exceptions for filesystem failures. The builtin understands wildcards, directory trees, and the optional `'f'` flag that forces overwrites of existing targets.",
+    "behaviors": [
+        "`status = copyfile(source, destination)` copies a file or folder and returns `1` on success and `0` on failure.",
+        "`[status, message, messageID] = copyfile(...)` adds MATLAB-style diagnostics. Successful copies return empty `1x0` character arrays.",
+        "`copyfile(source, destination, 'f')` forces overwrites, matching MATLAB's `'f'` flag. Without the flag, existing destination files or folders prevent the copy.",
+        "Wildcards in `source` (for example, `*.m`) copy every match. When the pattern expands to multiple items, `destination` must be an existing folder; each match is copied into that folder.",
+        "Folder copies replicate the entire directory tree, including nested files and subfolders, honoring read-only attributes where possible.",
+        "Inputs accept character vectors or string scalars. Other types raise MATLAB-compatible errors before any filesystem work occurs.",
+        "Paths resolve relative to the current working directory (`pwd`), and a leading `~` expands to the user's home directory on supported platforms."
+    ],
+    "examples": [
+        {
+            "description": "Copy a file into a new name in the same folder",
+            "input": "fid = fopen(\"report.txt\", \"w\"); fclose(fid);\nstatus = copyfile(\"report.txt\", \"report_backup.txt\")",
+            "output": "status =\n     1"
+        },
+        {
+            "description": "Copy a file into an existing destination folder",
+            "input": "mkdir(\"archive\");\nfid = fopen(\"summary.txt\", \"w\"); fclose(fid);\nstatus = copyfile(\"summary.txt\", \"archive\")",
+            "output": "status =\n     1"
+        },
+        {
+            "description": "Force overwrite an existing destination file",
+            "input": "fid = fopen(\"draft.txt\", \"w\"); fclose(fid);\nfid = fopen(\"final.txt\", \"w\"); fclose(fid);\n[status, message, messageID] = copyfile(\"draft.txt\", \"final.txt\", \"f\");\nstatus\nmessage\nmessageID",
+            "output": "status =\n     1\nmessage =\n\nmessageID ="
+        },
+        {
+            "description": "Copy an entire folder tree",
+            "input": "mkdir(\"data/raw\");\nfid = fopen(fullfile(\"data\", \"raw\", \"sample.dat\"), \"w\"); fclose(fid);\nstatus = copyfile(\"data\", \"data_copy\");\nstatus",
+            "output": "status =\n     1"
+        },
+        {
+            "description": "Copy multiple files with a wildcard pattern",
+            "input": "fid = fopen(\"a.log\", \"w\"); fclose(fid);\nfid = fopen(\"b.log\", \"w\"); fclose(fid);\nmkdir(\"logs\");\nstatus = copyfile(\"*.log\", \"logs\")",
+            "output": "status =\n     1"
+        },
+        {
+            "description": "Handle missing sources gracefully",
+            "input": "[status, message, messageID] = copyfile(\"missing.txt\", \"dest.txt\");\nstatus\nmessage\nmessageID",
+            "output": "status =\n     0\nmessage =\nSource \"missing.txt\" does not exist.\nmessageID =\nRunMat:COPYFILE:FileDoesNotExist"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What status codes does `copyfile` return?",
+            "answer": "`1` on success, `0` on failure. The numeric output is a double scalar to match MATLAB."
+        },
+        {
+            "question": "Does `copyfile` throw exceptions?",
+            "answer": "Only invalid inputs raise immediate errors. Filesystem failures surface through `status`, `message`, and `messageID`."
+        },
+        {
+            "question": "How do I overwrite existing files?",
+            "answer": "Pass `'f'` as the third argument. Without it, existing destinations prevent the copy."
+        },
+        {
+            "question": "Can I copy folders recursively?",
+            "answer": "Yes. When `source` refers to a folder, `copyfile` copies its entire contents (including subfolders) into `destination`."
+        },
+        {
+            "question": "What happens when the source and destination are the same?",
+            "answer": "The builtin reports a failure with `messageID = RunMat:COPYFILE:SourceEqualsDestination`, mirroring MATLAB's diagnostics."
+        },
+        {
+            "question": "Does `copyfile` preserve timestamps and permissions?",
+            "answer": "It delegates to the host operating system. RunMat attempts to preserve read-only attributes where possible, but platform differences may leave some metadata unchanged."
+        },
+        {
+            "question": "Can `copyfile` create intermediate destination folders?",
+            "answer": "`copyfile` does not invent new parent folders. Ensure the destination's parent path exists before calling the builtin."
+        },
+        {
+            "question": "Will GPU acceleration speed up `copyfile`?",
+            "answer": "No. The builtin operates entirely on the host CPU. GPU-resident strings are gathered automatically so existing scripts remain compatible."
+        },
+        {
+            "question": "Are wildcards supported on all platforms?",
+            "answer": "Yes. `copyfile(\"*.txt\", \"dest\")` expands using MATLAB-compatible glob semantics on every supported operating system."
+        }
+    ],
+    "links": [
+        {
+            "label": "movefile",
+            "url": "./movefile"
+        },
+        {
+            "label": "mkdir",
+            "url": "./mkdir"
+        },
+        {
+            "label": "rmdir",
+            "url": "./rmdir"
+        },
+        {
+            "label": "dir",
+            "url": "./dir"
+        },
+        {
+            "label": "pwd",
+            "url": "./pwd"
+        },
+        {
+            "label": "addpath",
+            "url": "./addpath"
+        },
+        {
+            "label": "cd",
+            "url": "./cd"
+        },
+        {
+            "label": "delete",
+            "url": "./delete"
+        },
+        {
+            "label": "exist",
+            "url": "./exist"
+        },
+        {
+            "label": "fullfile",
+            "url": "./fullfile"
+        },
+        {
+            "label": "genpath",
+            "url": "./genpath"
+        },
+        {
+            "label": "getenv",
+            "url": "./getenv"
+        },
+        {
+            "label": "ls",
+            "url": "./ls"
+        },
+        {
+            "label": "path",
+            "url": "./path"
+        },
+        {
+            "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/copyfile.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/repl_fs/copyfile.rs"
+    },
+    "gpu_residency": "No. `copyfile` always runs on the CPU. If callers supply GPU-resident strings, RunMat automatically gathers them before touching the filesystem so existing code continues to work. Keeping paths on the GPU offers no performance benefit.",
+    "gpu_behavior": [
+        "`copyfile` performs host-side filesystem I/O. When acceleration providers are active, RunMat first gathers any GPU-resident path arguments (for example, `gpuArray(\"data\")`) back to CPU memory, executes the copy entirely on the host, and returns host-resident outputs. Providers do not implement dedicated hooks for this builtin, so no GPU kernels are dispatched."
+    ],
+    "key": "copyfile",
+    "slug": "copyfile",
+    "categoryPath": [
+        "io",
+        "repl_fs"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=copyfile.js.map

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

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

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

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

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

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

package/dist/generated/builtins/corrcoef.js

@@ -0,0 +1,159 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "corrcoef",
+    "category": "stats/summary",
+    "keywords": [
+        "corrcoef",
+        "correlation",
+        "statistics",
+        "rows",
+        "normalization",
+        "gpu"
+    ],
+    "summary": "Compute Pearson correlation coefficients for the columns of matrices or paired data sets.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/corrcoef.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Runs entirely on the GPU when rows='all' and the provider exposes the corrcoef hook; other modes transparently gather to host."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::stats::summary::corrcoef::tests",
+        "integration": "builtins::stats::summary::corrcoef::tests::corrcoef_gpu_roundtrip",
+        "gpu": "builtins::stats::summary::corrcoef::tests::corrcoef_wgpu_matches_cpu"
+    },
+    "description": "`corrcoef` returns the Pearson correlation coefficients between pairs of variables. Given a matrix, every column is treated as a separate variable and every row is an observation. You can also pass two matching data sets and RunMat will concatenate them column-wise, mirroring MATLAB.",
+    "behaviors": [
+        "`corrcoef(X)` returns a square matrix whose `(i, j)` entry is the correlation between column `i` and column `j` of `X`.",
+        "`corrcoef(X, Y)` concatenates the columns of `X` and `Y` (they must share the same number of rows) before computing correlations.",
+        "An optional normalisation flag allows you to divide by `N - 1` (default, unbiased) or `N` (`flag = 1`, biased) just like MATLAB.",
+        "Use `'rows'` with `'all'`, `'complete'`, or `'pairwise'` to control how rows containing `NaN` or `Inf` are handled.",
+        "Columns with zero variance produce `NaN` on both the diagonal and in every correlation that references them, matching MATLAB semantics."
+    ],
+    "examples": [
+        {
+            "description": "Calculating correlation between matrix columns",
+            "input": "A = [1 2 4; 2 4 1; 3 6 -1; 4 8 0];\nR = corrcoef(A)",
+            "output": "R =\n    1.0000    1.0000   -0.8367\n    1.0000    1.0000   -0.8367\n   -0.8367   -0.8367    1.0000"
+        },
+        {
+            "description": "Correlating two separate data sets",
+            "input": "height = [1.72 1.84 1.65 1.91]';\nweight = [68.5 83.0 59.1 92.2]';\nR = corrcoef(height, weight)",
+            "output": "R =\n    1.0000    0.9998\n    0.9998    1.0000"
+        },
+        {
+            "description": "Ignoring rows that contain missing values",
+            "input": "X = [1 NaN  2;\n     3  4  5;\n     6  7 NaN];\nR = corrcoef(X, 'rows', 'complete')",
+            "output": "R =\n   NaN   NaN   NaN\n   NaN   NaN   NaN\n   NaN   NaN   NaN"
+        },
+        {
+            "description": "Pairwise correlation with staggered NaNs",
+            "input": "X = [ 1  2  3;\n     NaN 5  1;\n      4 NaN 6;\n      5  8 NaN];\nR = corrcoef(X, 'rows', 'pairwise')",
+            "output": "R =\n     1     1     1\n     1     1    -1\n     1    -1     1"
+        },
+        {
+            "description": "Using biased normalisation (`flag = 1`)",
+            "input": "A = [1 2; 3 4; 5 6];\nR = corrcoef(A, 1)",
+            "output": "R =\n    1.0000    1.0000\n    1.0000    1.0000"
+        },
+        {
+            "description": "Running `corrcoef` on `gpuArray` inputs",
+            "input": "G = gpuArray([1 2 4; 2 4 1; 3 6 -1; 4 8 0]);\nR = corrcoef(G);\nR_host = gather(R)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `corrcoef` support two outputs like MATLAB?",
+            "answer": "RunMat currently returns the correlation matrix (`R`) and omits the optional p-value output. The statistical distribution helpers needed for the p-values are on the roadmap."
+        },
+        {
+            "question": "How does the normalisation flag affect the result?",
+            "answer": "`flag = 0` (default) divides by `N - 1` for an unbiased estimate. `flag = 1` divides by `N`, producing biased estimates that match MATLAB. The choice does not change perfect correlations because both variance and covariance scale by the same factor."
+        },
+        {
+            "question": "What happens when a column is constant?",
+            "answer": "Columns with zero variance produce `NaN` on the diagonal and in any correlation that references that column. MATLAB behaves the same way because the standard deviation is zero."
+        },
+        {
+            "question": "Which rows are removed by `'rows','complete'`?",
+            "answer": "All rows that contain any `NaN` or `Inf` values are discarded before computing the correlation matrix. `'rows','pairwise'` performs this filtering separately for each column pair."
+        },
+        {
+            "question": "Can I call `corrcoef` on logical arrays?",
+            "answer": "Yes. Logical inputs are promoted to double precision (`true -> 1.0`, `false -> 0.0`) before the correlation matrix is computed."
+        },
+        {
+            "question": "What does corrcoef do in MATLAB?",
+            "answer": "`corrcoef(X)` returns the matrix of correlation coefficients for the columns of `X`. Each entry `R(i,j)` is the Pearson linear correlation between columns `i` and `j`, ranging from -1 to 1."
+        },
+        {
+            "question": "How is corrcoef different from cov in MATLAB?",
+            "answer": "`corrcoef` returns normalized correlation coefficients (always between -1 and 1), while `cov` returns the covariance matrix (in the original units squared). `corrcoef(X)` equals `cov(X) ./ (std(X)' * std(X))`."
+        },
+        {
+            "question": "Can I compute the correlation between two vectors with corrcoef?",
+            "answer": "Yes. `corrcoef(x, y)` treats `x` and `y` as two columns and returns a 2×2 correlation matrix. The off-diagonal element is the correlation coefficient between `x` and `y`."
+        },
+        {
+            "question": "Does corrcoef handle missing data?",
+            "answer": "Use `corrcoef(X, 'rows', 'complete')` to exclude any row that contains a `NaN` in any column, or `'pairwise'` to exclude NaN rows separately for each pair of columns."
+        }
+    ],
+    "links": [
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "histcounts",
+            "url": "./histcounts"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "cov",
+            "url": "./cov"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/stats/summary/corrcoef.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/stats/summary/corrcoef.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. When you write expressions such as `corrcoef(sin(X))`, the fusion planner keeps the intermediate residency on the GPU as long as the active provider exposes the required hooks (for `corrcoef`, that means the custom provider kernel and `rows='all'`). RunMat still honours MATLAB semantics, so explicitly calling `gpuArray` remains useful for compatibility and for forcing GPU residency when you are unsure whether the planner will do so.",
+    "gpu_behavior": [
+        "When the input data resides on the GPU, RunMat asks the active acceleration provider to execute the correlation directly on the device whenever:\n\n1. All inputs are `gpuArray` values; 2. The `'rows'` option is `'all'`; and 3. The provider exposes the custom `corrcoef` hook (the WGPU provider does).\n\nIf any of these conditions is not met, the builtin gathers the data to host memory, computes the correlation matrix on the CPU reference path, and returns a dense host tensor."
+    ],
+    "key": "corrcoef",
+    "slug": "corrcoef",
+    "categoryPath": [
+        "stats",
+        "summary"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=corrcoef.js.map

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

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

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

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

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

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