runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/csvread.js

@@ -0,0 +1,167 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "csvread",
+    "category": "io/tabular",
+    "keywords": [
+        "csvread",
+        "csv",
+        "comma-separated values",
+        "numeric import",
+        "range",
+        "header"
+    ],
+    "summary": "Read numeric data from a comma-separated text file with MATLAB-compatible zero-based ranges.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/csvread.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Performs host-side file I/O and parsing. Acceleration providers are not involved, and results remain on the CPU."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::io::tabular::csvread::tests",
+        "integration": "builtins::io::tabular::csvread::tests::csvread_basic_csv_roundtrip"
+    },
+    "description": "`csvread(filename)` reads numeric data from a comma-separated text file and returns a dense double-precision matrix. It is a legacy convenience wrapper preserved for MATLAB compatibility, and RunMat intentionally mirrors the original zero-based semantics.",
+    "behaviors": [
+        "Accepts character vectors or string scalars for the file name. String arrays must contain exactly one element.",
+        "`csvread(filename, row, col)` starts reading at the zero-based row `row` and column `col`, skipping any data before that offset.",
+        "`csvread(filename, row, col, range)` reads only the rectangle described by `range`. Numeric ranges must contain four elements `[r1 c1 r2 c2]` (zero-based, inclusive). Excel-style ranges use the familiar `\"B2:D6\"` A1 notation, which RunMat converts to zero-based indices internally.",
+        "Empty fields (two consecutive commas or a trailing comma) are interpreted as `0`. Tokens such as `NaN`, `Inf`, and `-Inf` are accepted (case-insensitive).",
+        "Any other nonnumeric token raises an error that identifies the offending row and column.",
+        "Results are dense double-precision tensors using column-major layout. An empty file produces a `0×0` tensor.",
+        "Paths can contain `~` to reference the home directory; RunMat expands the token before opening the file."
+    ],
+    "examples": [
+        {
+            "description": "Import Entire CSV File",
+            "input": "writematrix([1 2 3; 4 5 6], \"scores.csv\");\nM = csvread(\"scores.csv\");\ndisp(M);\ndelete(\"scores.csv\")",
+            "output": "M =\n     1     2     3\n     4     5     6"
+        },
+        {
+            "description": "Skip Header Row And Column Using Zero-Based Offsets",
+            "input": "fid = fopen(\"with_header.csv\", \"w\");\nfprintf(fid, \"Name,Jan,Feb\\nalpha,1,2\\nbeta,3,4\\n\");\nfclose(fid);\n\nM = csvread(\"with_header.csv\", 1, 1);\ndisp(M);\ndelete(\"with_header.csv\");",
+            "output": "M =\n     1     2\n     3     4"
+        },
+        {
+            "description": "Read A Specific Range With Numeric Vector Syntax",
+            "input": "fid = fopen(\"measurements.csv\", \"w\");\nfprintf(fid, \"10,11,12,13\\n14,15,16,17\\n18,19,20,21\\n22,23,24,25\\n\");\nfclose(fid);\n\nblock = csvread(\"measurements.csv\", 0, 0, [1 1 2 3])\ndelete(\"measurements.csv\");",
+            "output": "block =\n    15    16    17\n    19    20    21"
+        },
+        {
+            "description": "Read A Block Using Excel-Style Range Notation",
+            "input": "fid = fopen(\"measurements2.csv\", \"w\");\nfprintf(fid, \"10,11,12\\n14,15,16\\n18,19,20\\n\");\nfclose(fid);\n\nsub = csvread(\"measurements2.csv\", 0, 0, \"B2:C3\")\ndelete(\"measurements2.csv\");",
+            "output": "sub =\n    15    16\n    19    20"
+        },
+        {
+            "description": "Handle Empty Fields As Zeros",
+            "input": "fid = fopen(\"with_blanks.csv\", \"w\");\nfprintf(fid, \"1,,3\\n,5,\\n7,8,\\n\");\nfclose(fid);\n\nM = csvread(\"with_blanks.csv\")\ndelete(\"with_blanks.csv\");",
+            "output": "M =\n     1     0     3\n     0     5     0\n     7     8     0"
+        },
+        {
+            "description": "Read Numeric Data From A File In The Home Directory",
+            "input": "homePath = fullfile(getenv(\"HOME\"), \"runmat_csvread_home.csv\");\nfid = fopen(homePath, \"w\");\nfprintf(fid, \"9,10\\n11,12\\n\");\nfclose(fid);\n\nM = csvread(fullfile(\"~\", \"runmat_csvread_home.csv\"), 0, 0);\ndisp(M);\ndelete(homePath);",
+            "output": "M =\n     9    10\n    11    12"
+        },
+        {
+            "description": "Detect Errors When Text Appears In Numeric Columns",
+            "input": "fid = fopen(\"bad.csv\", \"w\");\nfprintf(fid, \"1,2,3\\n4,error,6\\n\");\nfclose(fid);\n\ntry\n    csvread(\"bad.csv\");\ncatch err\n    disp(err.message);\nend\ndelete(\"bad.csv\");",
+            "output": "csvread: nonnumeric token error at row 2 column 2"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why does `csvread` complain about text data?",
+            "answer": "`csvread` is limited to numeric CSV content. If a field contains letters, quoted strings, or other tokens that cannot be parsed as numbers, the builtin raises an error. Switch to `readmatrix` or `readtable` when the file mixes text and numbers."
+        },
+        {
+            "question": "Are the row and column offsets zero-based?",
+            "answer": "Yes. `csvread(filename, row, col)` treats `row` and `col` as zero-based counts to skip from the start of the file before reading results."
+        },
+        {
+            "question": "How are Excel-style ranges interpreted?",
+            "answer": "Excel ranges such as `\"B2:D5\"` use the familiar 1-based row numbering and column letters. The builtin converts them internally to zero-based indices and includes both endpoints."
+        },
+        {
+            "question": "Can I read files with quoted numeric fields?",
+            "answer": "Quoted numeric fields are not supported. Remove quotes before calling `csvread`, or switch to `readmatrix`, which has full CSV parsing support."
+        },
+        {
+            "question": "What happens to empty cells?",
+            "answer": "Empty cells (two consecutive commas or a trailing delimiter) become zero, matching MATLAB's `csvread` behaviour."
+        },
+        {
+            "question": "Does `csvread` support custom delimiters?",
+            "answer": "No. `csvread` always uses comma separation. Use `dlmread` or `readmatrix` for other delimiters."
+        },
+        {
+            "question": "How do I keep the results on the GPU?",
+            "answer": "`csvread` returns a host tensor. Call `gpuArray(csvread(...))` after reading, or prefer `readmatrix` with `'Like', gpuArray.zeros(1)` to keep residency on the GPU automatically."
+        },
+        {
+            "question": "What if the file is empty?",
+            "answer": "An empty file results in a `0×0` double tensor. MATLAB behaves the same way."
+        },
+        {
+            "question": "Does `csvread` change the working directory?",
+            "answer": "No. Relative paths are resolved against the current working directory and do not modify it."
+        }
+    ],
+    "links": [
+        {
+            "label": "readmatrix",
+            "url": "./readmatrix"
+        },
+        {
+            "label": "writematrix",
+            "url": "./writematrix"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "csvwrite",
+            "url": "./csvwrite"
+        },
+        {
+            "label": "dlmread",
+            "url": "./dlmread"
+        },
+        {
+            "label": "dlmwrite",
+            "url": "./dlmwrite"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/io/tabular/csvread.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/tabular/csvread.rs"
+    },
+    "gpu_residency": "`csvread` always returns a host-resident tensor because it performs file I/O and parsing on the CPU. If you need the data on the GPU, wrap the call with `gpuArray(csvread(...))` or switch to `readmatrix` with the `'Like'` option so that RunMat can place the result directly on the desired device.",
+    "gpu_behavior": [
+        "`csvread` performs all work on the host CPU. Arguments are gathered from the GPU when necessary, and the resulting tensor is returned in host memory. To keep data on the GPU, call `gpuArray` on the output or switch to `readmatrix` with the `'Like'` option. No provider hooks are required."
+    ],
+    "key": "csvread",
+    "slug": "csvread",
+    "categoryPath": [
+        "io",
+        "tabular"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=csvread.js.map

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

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

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

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

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

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

package/dist/generated/builtins/csvwrite.js

@@ -0,0 +1,153 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "csvwrite",
+    "category": "io/tabular",
+    "keywords": [
+        "csvwrite",
+        "csv",
+        "write",
+        "comma-separated values",
+        "numeric export",
+        "row offset",
+        "column offset"
+    ],
+    "summary": "Write numeric matrices to comma-separated text files using MATLAB-compatible offsets.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/csvwrite.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs entirely on the CPU. gpuArray inputs are gathered before serialisation."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::io::tabular::csvwrite::tests",
+        "integration": [
+            "builtins::io::tabular::csvwrite::tests::csvwrite_writes_basic_matrix",
+            "builtins::io::tabular::csvwrite::tests::csvwrite_honours_offsets",
+            "builtins::io::tabular::csvwrite::tests::csvwrite_handles_gpu_tensors",
+            "builtins::io::tabular::csvwrite::tests::csvwrite_expands_home_directory",
+            "builtins::io::tabular::csvwrite::tests::csvwrite_formats_with_short_g_precision",
+            "builtins::io::tabular::csvwrite::tests::csvwrite_handles_wgpu_provider_gather",
+            "builtins::io::tabular::csvwrite::tests::csvwrite_rejects_negative_offsets"
+        ]
+    },
+    "description": "`csvwrite(filename, M)` writes a numeric matrix to a comma-separated text file. The builtin honours MATLAB's historical zero-based row/column offset arguments so that existing scripts continue to behave identically in RunMat.",
+    "behaviors": [
+        "Only real numeric or logical inputs are accepted. Logical values are converted to `0` and `1` before writing. Complex and textual inputs raise descriptive errors.",
+        "`csvwrite(filename, M, row, col)` starts writing at zero-based row `row` and column `col`, leaving earlier rows blank and earlier columns empty within each row. Offsets must be non-negative integers.",
+        "Matrices must be 2-D (trailing singleton dimensions are ignored). Column-major ordering is respected when serialising to text.",
+        "Numbers are emitted using MATLAB-compatible short `g` formatting (`%.5g`). `NaN`, `Inf`, and `-Inf` tokens are written verbatim.",
+        "Existing files are overwritten. `csvwrite` does not support appending; switch to `writematrix` with `'WriteMode','append'` when the behaviour is required.",
+        "Paths that begin with `~` expand to the user's home directory before writing."
+    ],
+    "examples": [
+        {
+            "description": "Writing a numeric matrix to CSV",
+            "input": "A = [1 2 3; 4 5 6];\ncsvwrite(\"scores.csv\", A)"
+        },
+        {
+            "description": "Starting output after a header row",
+            "input": "fid = fopen(\"with_header.csv\", \"w\");\nfprintf(fid, \"Name,Jan,Feb\\nalpha,1,2\\nbeta,3,4\\n\");\nfclose(fid);\n\ncsvwrite(\"with_header.csv\", [10 20; 30 40], 1, 0)"
+        },
+        {
+            "description": "Skipping leading columns before data",
+            "input": "B = magic(3);\ncsvwrite(\"offset_columns.csv\", B, 0, 2)"
+        },
+        {
+            "description": "Exporting logical masks as numeric zeros and ones",
+            "input": "mask = [true false true; false true false];\ncsvwrite(\"mask.csv\", mask)"
+        },
+        {
+            "description": "Writing GPU-resident data without manual gather",
+            "input": "G = gpuArray(single([0.1 0.2 0.3]));\nbytes = csvwrite(\"gpu_values.csv\", G)",
+            "output": "bytes = 12"
+        },
+        {
+            "description": "Persisting a scalar value for downstream tools",
+            "input": "total = sum(rand(5));\ncsvwrite(\"scalar.csv\", total)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why must the input be numeric or logical?",
+            "answer": "`csvwrite` predates MATLAB's table and string support and only serialises numeric values. Provide numeric matrices or logical masks, or switch to `writematrix` when you need to mix text and numbers."
+        },
+        {
+            "question": "Are row and column offsets zero-based?",
+            "answer": "Yes. `row = 1` skips one full line before writing, and `col = 2` inserts two empty comma-separated fields at the start of each written row."
+        },
+        {
+            "question": "Can I append to an existing CSV with `csvwrite`?",
+            "answer": "No. `csvwrite` always overwrites the destination file. Use `writematrix` with `'WriteMode','append'` or manipulate the file with lower-level I/O functions."
+        },
+        {
+            "question": "How are `NaN` and `Inf` values written?",
+            "answer": "They are emitted verbatim as `NaN`, `Inf`, or `-Inf`, matching MATLAB's text representation so that downstream tools can parse them consistently."
+        },
+        {
+            "question": "What line ending does `csvwrite` use?",
+            "answer": "The builtin uses the platform default (`\\r\\n` on Windows, `\\n` elsewhere). Most CSV consumers handle either convention transparently."
+        }
+    ],
+    "links": [
+        {
+            "label": "csvread",
+            "url": "./csvread"
+        },
+        {
+            "label": "readmatrix",
+            "url": "./readmatrix"
+        },
+        {
+            "label": "writematrix",
+            "url": "./writematrix"
+        },
+        {
+            "label": "fprintf",
+            "url": "./fprintf"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "dlmread",
+            "url": "./dlmread"
+        },
+        {
+            "label": "dlmwrite",
+            "url": "./dlmwrite"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/io/tabular/csvwrite.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/tabular/csvwrite.rs"
+    },
+    "gpu_residency": "No additional steps are necessary. `csvwrite` treats GPU arrays as residency sinks: data is gathered back to host memory prior to writing. This matches MATLAB's behaviour, where file I/O always operates on host-resident values.",
+    "gpu_behavior": [
+        "`csvwrite` always executes on the host CPU. When the matrix resides on the GPU, RunMat gathers the data through the active acceleration provider before serialisation. No provider hooks are required, and the return value reports the number of bytes written after the gather completes."
+    ],
+    "key": "csvwrite",
+    "slug": "csvwrite",
+    "categoryPath": [
+        "io",
+        "tabular"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=csvwrite.js.map

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

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

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

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

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

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

package/dist/generated/builtins/ctranspose.js

@@ -0,0 +1,174 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "ctranspose",
+    "category": "math/linalg/ops",
+    "keywords": [
+        "ctranspose",
+        "conjugate transpose",
+        "hermitian",
+        "gpu",
+        "matrix transpose"
+    ],
+    "summary": "Swap the first two dimensions of arrays and conjugate complex values.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/ctranspose.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Invokes provider transpose/permute plus unary_conj hooks when available; otherwise gathers to host, applies the conjugate transpose, and re-uploads."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::linalg::ops::ctranspose::tests",
+        "integration": "builtins::math::linalg::ops::ctranspose::tests::ctranspose_gpu_roundtrip",
+        "gpu": "builtins::math::linalg::ops::ctranspose::tests::ctranspose_wgpu_matches_cpu"
+    },
+    "description": "`B = ctranspose(A)` (or `B = A'`) flips the first two dimensions of `A` **and** conjugates complex values. Real-valued inputs therefore behave like `transpose`, while complex inputs receive Hermitian conjugation.",
+    "behaviors": [
+        "Works for scalars, vectors, matrices, and N-D arrays; only the first two axes are swapped.",
+        "Real numeric, logical, and character data are not changed by conjugation.",
+        "Complex values receive element-wise conjugation after the transpose (`(a + bi)' = a - bi`).",
+        "Character arrays and cell arrays preserve their types; `ctranspose` simply rearranges entries.",
+        "String scalars are passed through unchanged; string arrays transpose like MATLAB.",
+        "Empty arrays and singleton dimensions follow MATLAB's column-major semantics."
+    ],
+    "examples": [
+        {
+            "description": "Conjugate transpose of a complex matrix",
+            "input": "Z = [1+2i 3-4i; 5+0i 6-7i];\nH = ctranspose(Z)",
+            "output": "H =\n   1 - 2i   5 - 0i\n   3 + 4i   6 + 7i"
+        },
+        {
+            "description": "Conjugate transpose of a real matrix equals the plain transpose",
+            "input": "A = [1 2 3; 4 5 6];\nB = ctranspose(A)",
+            "output": "B =\n     1     4\n     2     5\n     3     6"
+        },
+        {
+            "description": "Conjugate transpose turns row vectors into column vectors",
+            "input": "row = [1-2i, 3+4i, 5];\ncol = ctranspose(row);\nsize(col)",
+            "output": "ans = [3 1]"
+        },
+        {
+            "description": "Conjugate transpose of a complex scalar",
+            "input": "z = 2 + 3i;\nresult = ctranspose(z)",
+            "output": "result = 2 - 3i"
+        },
+        {
+            "description": "Conjugate transpose of text data preserves characters",
+            "input": "C = ['r' 'u' 'n'; 'm' 'a' 't'];\nCT = ctranspose(C)",
+            "output": "CT =\n    'rm'\n    'ua'\n    'nt'"
+        },
+        {
+            "description": "Conjugate transpose of a gpuArray without leaving the device",
+            "input": "G = gpuArray(rand(1024, 64) + 1i * rand(1024, 64));\nGT = ctranspose(G)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How is `ctranspose` different from `transpose`?",
+            "answer": "`transpose` (`A.'`) swaps dimensions without conjugation; `ctranspose` (`A'`) also conjugates complex values. For purely real data they are identical."
+        },
+        {
+            "question": "Does `ctranspose` change logical or character arrays?",
+            "answer": "Only their layout changes. Values remain logical or character, and conjugation has no effect."
+        },
+        {
+            "question": "What about higher-dimensional arrays?",
+            "answer": "Only the first two axes are swapped; trailing dimensions stay in-place, matching MATLAB."
+        },
+        {
+            "question": "Does the result share storage with the input?",
+            "answer": "No. `ctranspose` materialises a fresh array, although fusion may eliminate the copy in optimised pipelines."
+        },
+        {
+            "question": "How are complex tensors handled on the GPU today?",
+            "answer": "Complex gpuArray support is still in flight. When complex data appears, RunMat gathers to the host, applies the conjugate transpose, and re-uploads if needed."
+        },
+        {
+            "question": "Will `ctranspose` fuse with neighbouring kernels?",
+            "answer": "Conjugate transposes currently act as fusion boundaries so that shape changes are visible to downstream kernels."
+        },
+        {
+            "question": "Can I rely on `ctranspose` inside linear-algebra routines (e.g., Hermitian products)?",
+            "answer": "Yes. The builtin mirrors MATLAB semantics precisely and is safe to use inside idioms like `A' * A`."
+        },
+        {
+            "question": "What error do I get for unsupported types?",
+            "answer": "Non-numeric objects (e.g., structs) raise `ctranspose: unsupported input type ...`, matching MATLAB's strict type checks."
+        }
+    ],
+    "links": [
+        {
+            "label": "transpose",
+            "url": "./transpose"
+        },
+        {
+            "label": "conj",
+            "url": "./conj"
+        },
+        {
+            "label": "mtimes",
+            "url": "./mtimes"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "dot",
+            "url": "./dot"
+        },
+        {
+            "label": "mldivide",
+            "url": "./mldivide"
+        },
+        {
+            "label": "mpower",
+            "url": "./mpower"
+        },
+        {
+            "label": "mrdivide",
+            "url": "./mrdivide"
+        },
+        {
+            "label": "trace",
+            "url": "./trace"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/linalg/ops/ctranspose.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/linalg/ops/ctranspose.rs"
+    },
+    "gpu_residency": "No additional residency management is required. If the planner keeps your data on the GPU, `ctranspose` honours that residency and either executes on the device (when hooks are present) or performs a gather/transpose/upload round-trip automatically.",
+    "gpu_behavior": [
+        "**Provider support:** If the backend exposes both `transpose` (or `permute`) and `unary_conj`, the entire operation happens on the device without a gather.",
+        "**Partial hooks:** If the transpose succeeds but conjugation fails, RunMat falls back to the host path while logging a warning so users know their backend is incomplete.",
+        "**No hooks:** RunMat gathers the tensor, applies the conjugate transpose on the CPU, and re-uploads the result when possible so downstream kernels can keep running on the GPU.\n\nCurrent providers operate on real double-precision tensors; complex GPU tensors will gather to the host until native complex layouts are implemented."
+    ],
+    "key": "ctranspose",
+    "slug": "ctranspose",
+    "categoryPath": [
+        "math",
+        "linalg",
+        "ops"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=ctranspose.js.map

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

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

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

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

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

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