runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/toc.js

@@ -0,0 +1,118 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "toc",
+    "category": "timing",
+    "keywords": [
+        "toc",
+        "timer",
+        "elapsed time",
+        "profiling",
+        "benchmark"
+    ],
+    "summary": "Read the elapsed time since the most recent tic or an explicit handle.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "toc always runs on the host CPU. GPU providers are not consulted."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::timing::toc::tests",
+        "integration": "builtins::timing::toc::tests"
+    },
+    "description": "`toc` returns the elapsed wall-clock time in seconds since the last matching `tic`, or since the `tic` handle you pass as an argument. It mirrors the stopwatch utilities that MATLAB users rely on for ad-hoc profiling and benchmarking.",
+    "behaviors": [
+        "`toc` without inputs pops the most recent `tic` from the stopwatch stack and returns the elapsed seconds.",
+        "`toc(t)` accepts a handle previously produced by `tic` and measures the time since that handle without altering the stack.",
+        "Calling `toc` before `tic` raises the MATLAB-compatible error identifier `RunMat:toc:NoMatchingTic`.",
+        "Passing anything other than a finite, non-negative scalar handle raises `RunMat:toc:InvalidTimerHandle`.",
+        "The stopwatch uses a monotonic host clock, so measurements are immune to wall-clock adjustments."
+    ],
+    "examples": [
+        {
+            "description": "Measuring elapsed time since the last tic",
+            "input": "tic;\npause(0.25);\nelapsed = toc"
+        },
+        {
+            "description": "Using toc with an explicit tic handle",
+            "input": "token = tic;\nheavyComputation();\nelapsed = toc(token)"
+        },
+        {
+            "description": "Timing nested stages with toc",
+            "input": "tic;          % Outer stopwatch\nstage1();\ninner = tic;  % Nested stopwatch\nstage2();\nstage2Time = toc(inner);\ntotalTime = toc"
+        },
+        {
+            "description": "Printing elapsed time without capturing output",
+            "input": "tic;\nlongRunningTask();\ntoc;   % Displays the elapsed seconds because the result is not assigned"
+        },
+        {
+            "description": "Measuring immediately with toc(tic)",
+            "input": "elapsed = toc(tic);  % Starts a timer and reads it right away"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What happens if I call `toc` before `tic`?",
+            "answer": "The builtin raises `RunMat:toc:NoMatchingTic`, matching MATLAB's behaviour when no stopwatch start exists."
+        },
+        {
+            "question": "Does `toc` remove the matching `tic`?",
+            "answer": "Yes when called without arguments. The most-recent stopwatch entry is popped so nested timers unwind in order. When you pass a handle (`toc(t)`), the stack remains unchanged and you may reuse the handle multiple times."
+        },
+        {
+            "question": "Can I reuse a `tic` handle after calling `toc(t)`?",
+            "answer": "Yes. Handles are deterministic timestamps, so you can call `toc(handle)` multiple times or store the handle in structures for later inspection."
+        },
+        {
+            "question": "Does `toc` print output?",
+            "answer": "When you do not capture the result, the interpreter shows the elapsed seconds. Assigning the return value (or ending the statement with a semicolon) suppresses the display, just like in MATLAB."
+        },
+        {
+            "question": "Is `toc` affected by GPU execution or fusion?",
+            "answer": "No. The stopwatch uses the host's monotonic clock. GPU acceleration, fusion, and pipeline residency do not change the measured interval."
+        },
+        {
+            "question": "How accurate is the reported time?",
+            "answer": "`toc` relies on the same monotonic clock (`runmat_time::Instant`), typically offering microsecond precision on modern platforms. The actual resolution depends on your operating system."
+        }
+    ],
+    "links": [
+        {
+            "label": "tic",
+            "url": "./tic"
+        },
+        {
+            "label": "pause",
+            "url": "./pause"
+        },
+        {
+            "label": "timeit",
+            "url": "./timeit"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/timing/toc.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/timing/toc.rs"
+    },
+    "gpu_residency": "No. Timing utilities never touch GPU memory. You can freely combine `toc` with code that produces or consumes `gpuArray` values—the stopwatch itself still executes on the CPU.",
+    "gpu_behavior": [
+        "The stopwatch lives entirely on the host. `toc` never transfers tensors or consults acceleration providers, so there are no GPU hooks to implement. Expressions that combine `toc` with GPU-resident data gather any numeric operands back to the CPU before evaluating the timer logic, and the builtin is excluded from fusion plans entirely."
+    ],
+    "key": "toc",
+    "slug": "toc",
+    "categoryPath": [
+        "timing"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=toc.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"toc.js","sourceRoot":"","sources":["../../../src/generated/builtins/toc.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,KAAK;IACd,UAAU,EAAE,QAAQ;IACpB,UAAU,EAAE;QACV,KAAK;QACL,OAAO;QACP,cAAc;QACd,WAAW;QACX,WAAW;KACZ;IACD,SAAS,EAAE,wEAAwE;IACnF,YAAY,EAAE,EAAE;IAChB,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,mEAAmE;KAC7E;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,8BAA8B;QACtC,aAAa,EAAE,8BAA8B;KAC9C;IACD,aAAa,EAAE,4OAA4O;IAC3P,WAAW,EAAE;QACX,2GAA2G;QAC3G,4HAA4H;QAC5H,sGAAsG;QACtG,0GAA0G;QAC1G,kGAAkG;KACnG;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,mCAAmC;SAC7C;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,yDAAyD;SACnE;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,oIAAoI;SAC9I;QACD;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,oGAAoG;SAC9G;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,+DAA+D;SACzE;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,4GAA4G;SACvH;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,4NAA4N;SACvO;QACD;YACE,UAAU,EAAE,oDAAoD;YAChE,QAAQ,EAAE,iJAAiJ;SAC5J;QACD;YACE,UAAU,EAAE,0BAA0B;YACtC,QAAQ,EAAE,mMAAmM;SAC9M;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,0IAA0I;SACrJ;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,0LAA0L;SACrM;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,oDAAoD;QAC7D,KAAK,EAAE,iGAAiG;KACzG;IACD,eAAe,EAAE,iLAAiL;IAClM,cAAc,EAAE;QACd,kVAAkV;KACnV;IACD,KAAK,EAAE,KAAK;IACZ,MAAM,EAAE,KAAK;IACb,cAAc,EAAE;QACd,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/trace.js

@@ -0,0 +1,184 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "trace",
+    "category": "math/linalg/ops",
+    "keywords": [
+        "trace",
+        "matrix trace",
+        "diagonal sum",
+        "gpu"
+    ],
+    "summary": "Sum the diagonal elements of matrices and matrix-like tensors.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/trace.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": true,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Prefers provider diag+sum hooks; otherwise gathers once, computes on the CPU, and re-uploads a 1×1 result so downstream GPU work can continue."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::linalg::ops::trace::tests",
+        "integration": "builtins::math::linalg::ops::trace::tests::trace_gpu_provider_roundtrip",
+        "gpu": "builtins::math::linalg::ops::trace::tests::trace_wgpu_matches_cpu"
+    },
+    "description": "`trace(A)` returns the sum of the elements on the main diagonal of `A`. The result matches MATLAB for scalars, vectors, rectangular matrices, logical masks, and complex inputs. When the argument is a `gpuArray`, RunMat keeps the result on the GPU whenever the active provider exposes the required hooks.",
+    "behaviors": [
+        "Operates on the leading two dimensions. Higher dimensions must be singleton; otherwise an error is raised.",
+        "Works for non-square matrices by summing up to `min(size(A, 1), size(A, 2))`.",
+        "Scalars (real or complex) return their own value.",
+        "Logical inputs are promoted to double precision (`true → 1.0`, `false → 0.0`).",
+        "Complex inputs retain both real and imaginary parts in the result.",
+        "Empty matrices yield `0`. Empty complex matrices yield `0 + 0i`.",
+        "`gpuArray` inputs stay on the device when the provider implements diagonal extraction and sum reductions; otherwise RunMat gathers once, computes on the host, and uploads a 1×1 scalar."
+    ],
+    "examples": [
+        {
+            "description": "Summing the diagonal of a square matrix",
+            "input": "A = [1 2 3; 4 5 6; 7 8 9];\nt = trace(A)",
+            "output": "t = 15"
+        },
+        {
+            "description": "Computing the trace of a rectangular matrix",
+            "input": "B = [4 2; 1 3; 5 6];\nresult = trace(B)",
+            "output": "result = 7"
+        },
+        {
+            "description": "Getting the trace of a triangular matrix",
+            "input": "U = [4 1 2; 0 5 3; 0 0 6];\ntri_trace = trace(U)",
+            "output": "tri_trace = 15"
+        },
+        {
+            "description": "Working with complex-valued matrices",
+            "input": "Z = [1+2i 2; 3 4-5i];\nzTrace = trace(Z)",
+            "output": "zTrace = 5.0000 - 3.0000i"
+        },
+        {
+            "description": "Tracing a gpuArray without gathering",
+            "input": "G = gpuArray(rand(1024));\ngpuResult = trace(G);     % stays on the GPU\nscalarHost = gather(gpuResult)"
+        },
+        {
+            "description": "Handling empty matrices safely",
+            "input": "E = zeros(0, 5);\nvalue = trace(E)",
+            "output": "value = 0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What happens if my matrix is not square?",
+            "answer": "`trace` sums along the main diagonal up to `min(m, n)`, matching MATLAB behaviour for rectangular matrices."
+        },
+        {
+            "question": "Does `trace` accept higher-dimensional arrays?",
+            "answer": "Only when trailing dimensions are singleton. Otherwise it raises an error because MATLAB restricts `trace` to 2-D matrix slices."
+        },
+        {
+            "question": "How are logical inputs handled?",
+            "answer": "Logical values are promoted to double precision (0.0 or 1.0) before summing, mirroring MATLAB semantics."
+        },
+        {
+            "question": "What is returned for empty inputs?",
+            "answer": "Empty real matrices produce `0`; empty complex matrices produce `0 + 0i`, exactly like MATLAB."
+        },
+        {
+            "question": "Does the result stay on the GPU?",
+            "answer": "Yes, when the provider implements the required hooks. Otherwise RunMat re-uploads the scalar so later GPU-friendly code still sees a `gpuArray`."
+        },
+        {
+            "question": "Can I call `trace` on complex data?",
+            "answer": "Absolutely. The result is a complex scalar containing the sum of the diagonal's real and imaginary parts."
+        },
+        {
+            "question": "Is there any precision loss with large matrices?",
+            "answer": "`trace` accumulates in double precision (`f64`), matching MATLAB's default numeric type."
+        },
+        {
+            "question": "Does `trace` modify the input matrix?",
+            "answer": "No. It reads the diagonal and returns a new scalar without altering the original matrix or its residency."
+        },
+        {
+            "question": "How does `trace` interact with sparse matrices?",
+            "answer": "Sparse support is planned; current releases operate on dense arrays. Inputs are treated as dense matrices."
+        },
+        {
+            "question": "Can I rely on `trace` inside fused GPU expressions?",
+            "answer": "Fused kernels treat `trace` as a scalar reduction boundary. The planner emits GPU kernels when hooks are available; otherwise it falls back gracefully."
+        }
+    ],
+    "links": [
+        {
+            "label": "diag",
+            "url": "./diag"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "mtimes",
+            "url": "./mtimes"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "ctranspose",
+            "url": "./ctranspose"
+        },
+        {
+            "label": "dot",
+            "url": "./dot"
+        },
+        {
+            "label": "mldivide",
+            "url": "./mldivide"
+        },
+        {
+            "label": "mpower",
+            "url": "./mpower"
+        },
+        {
+            "label": "mrdivide",
+            "url": "./mrdivide"
+        },
+        {
+            "label": "transpose",
+            "url": "./transpose"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/linalg/ops/trace.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/linalg/ops/trace.rs"
+    },
+    "gpu_residency": "You usually do NOT need to call `gpuArray` yourself in RunMat (unlike MATLAB).\n\nThe auto-offload planner keeps residency on the GPU when expressions benefit from it. When the active provider exposes both `diag_extract` and `reduce_sum`, `trace` executes entirely on the GPU. If either hook is missing, RunMat performs a single gather, computes the scalar on the CPU, and uploads a 1×1 result back to the device so downstream fused expressions continue to operate on GPU data.\n\nTo preserve backwards compatibility with MathWorks MATLAB—and for situations where you want to explicitly manage residency—you can wrap inputs with `gpuArray`. This mirrors MATLAB while still letting RunMat's planner decide whether the GPU offers an advantage for the surrounding code.",
+    "gpu_behavior": [
+        "1. When the input already lives on the GPU and the active provider exposes both `diag_extract` and `reduce_sum`, RunMat extracts the diagonal on device and performs the reduction there, returning a `1×1` gpuArray that stays resident for downstream work. 2. If either hook is missing or the provider declines (unsupported precision, shape, or size), RunMat gathers the matrix exactly once, computes the diagonal sum on the CPU, and uploads the scalar back to the provider so subsequent GPU-friendly code keeps running on device memory. 3. Mixed-residency calls automatically upload host matrices before these steps, matching MATLAB's `gpuArray` behaviour while letting the auto-offload planner decide which tier benefits the most."
+    ],
+    "key": "trace",
+    "slug": "trace",
+    "categoryPath": [
+        "math",
+        "linalg",
+        "ops"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=trace.js.map

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

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

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

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

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

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

package/dist/generated/builtins/transpose.js

@@ -0,0 +1,179 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "transpose",
+    "category": "math/linalg/ops",
+    "keywords": [
+        "transpose",
+        "swap rows and columns",
+        "non-conjugate transpose",
+        "gpu"
+    ],
+    "summary": "Swap the first two dimensions of arrays without taking the complex conjugate.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/transpose.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Prefers the provider transpose hook; falls back to gather→transpose→upload when unavailable."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::linalg::ops::transpose::tests",
+        "integration": "builtins::math::linalg::ops::transpose::tests::transpose_gpu_roundtrip",
+        "gpu": "builtins::math::linalg::ops::transpose::tests::transpose_wgpu_matches_cpu"
+    },
+    "description": "`B = transpose(A)` flips the first two dimensions of `A` without conjugating complex values. It is equivalent to the MATLAB syntax `A.'` and leaves higher dimensions untouched.",
+    "behaviors": [
+        "Works for scalars, vectors, matrices, and N-D arrays; only the first two axes are swapped.",
+        "Complex values are **not** conjugated. Use `ctranspose`/`A'` for conjugate transpose.",
+        "Logical, string, character, and cell arrays preserve their types and metadata.",
+        "Vectors become column or row matrices as needed (e.g., `size(transpose(1:3)) == [3 1]`).",
+        "Empty and singleton dimensions follow MATLAB's column-major semantics."
+    ],
+    "examples": [
+        {
+            "description": "Transposing a numeric matrix to swap rows and columns",
+            "input": "A = [1 2 3; 4 5 6];\nB = transpose(A)",
+            "output": "B =\n     1     4\n     2     5\n     3     6"
+        },
+        {
+            "description": "Turning a row vector into a column vector",
+            "input": "row = 1:4;\ncol = transpose(row);\nsize(col)",
+            "output": "ans = [4 1]"
+        },
+        {
+            "description": "Preserving imaginary parts when transposing complex matrices",
+            "input": "Z = [1+2i 3-4i];\nZT = transpose(Z)",
+            "output": "ZT =\n     1.0000 + 2.0000i\n     3.0000 - 4.0000i"
+        },
+        {
+            "description": "Transposing logical masks while keeping logical type",
+            "input": "mask = logical([1 0 1; 0 1 0]);\nmaskT = transpose(mask);\nclass(maskT)",
+            "output": "ans = 'logical'"
+        },
+        {
+            "description": "Transposing character arrays to flip rows and columns of text",
+            "input": "C = ['r' 'u' 'n'; 'm' 'a' 't'];\nCT = transpose(C)",
+            "output": "CT =\n    'rm'\n    'ua'\n    'nt'"
+        },
+        {
+            "description": "Transposing gpuArray data without leaving the device",
+            "input": "G = gpuArray(rand(1024, 32));\nGT = transpose(G);\nisgpuarray(GT)",
+            "output": "ans = logical 1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `transpose` conjugate complex numbers?",
+            "answer": "No. Use `ctranspose` or the `'` operator for conjugate transpose."
+        },
+        {
+            "question": "What happens for tensors with more than two dimensions?",
+            "answer": "Only the first two axes are swapped; higher dimensions remain in-place."
+        },
+        {
+            "question": "Do empty matrices stay empty after transposition?",
+            "answer": "Yes. MATLAB's empty-dimension rules are preserved exactly."
+        },
+        {
+            "question": "Is the result a copy or a view?",
+            "answer": "It is a new array. Neither the input nor the output share storage."
+        },
+        {
+            "question": "Can I transpose cell arrays?",
+            "answer": "Yes—RunMat mirrors MATLAB by rearranging each cell handle into the new layout."
+        },
+        {
+            "question": "Are logical arrays still logical after transpose?",
+            "answer": "Absolutely. The data stay in compact logical storage."
+        },
+        {
+            "question": "How does `transpose` interact with the fusion planner?",
+            "answer": "Fusion treats transposes as pipeline boundaries, so kernels before and after the transpose can still fuse independently."
+        },
+        {
+            "question": "What if my provider lacks a transpose kernel?",
+            "answer": "RunMat transparently gathers, transposes on the host, and re-uploads while logging a warning."
+        },
+        {
+            "question": "Does `transpose` change sparse matrices?",
+            "answer": "Sparse support is planned; current releases operate on dense arrays."
+        },
+        {
+            "question": "Can I compose `transpose` with `permute`?",
+            "answer": "Yes—`transpose` is equivalent to `permute(A, [2 1 3 ...])`."
+        }
+    ],
+    "links": [
+        {
+            "label": "ctranspose",
+            "url": "./ctranspose"
+        },
+        {
+            "label": "permute",
+            "url": "./permute"
+        },
+        {
+            "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/transpose.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/linalg/ops/transpose.rs"
+    },
+    "gpu_residency": "No additional residency management is required. If the planner keeps your data on the GPU, `transpose` will honour that residency and either invoke a provider kernel or, in the worst case, perform a gather/transpose/upload round-trip automatically.",
+    "gpu_behavior": [
+        "When a gpuArray is provided, RunMat first asks the active Accel provider for a dedicated transpose kernel. The WGPU backend ships such a kernel today; other providers may supply their own implementation. If the hook is missing, RunMat gathers the data to the host, performs the transpose once, and re-uploads it so downstream GPU work continues without residency churn."
+    ],
+    "key": "transpose",
+    "slug": "transpose",
+    "categoryPath": [
+        "math",
+        "linalg",
+        "ops"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=transpose.js.map

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

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

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

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

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

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