runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/flip.js

@@ -0,0 +1,199 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "flip",
+    "category": "array/shape",
+    "keywords": [
+        "flip",
+        "reverse",
+        "dimension",
+        "gpu",
+        "horizontal",
+        "vertical"
+    ],
+    "summary": "Reverse the order of elements along specific dimensions.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64",
+            "i32",
+            "bool"
+        ],
+        "broadcasting": "none",
+        "notes": "Attempts to flip tensors directly on the device when providers expose a flip hook; otherwise gathers once, flips on the host, and re-uploads to keep results gpu-resident."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::shape::flip::tests",
+        "integration": "builtins::array::shape::flip::tests::flip_gpu_roundtrip"
+    },
+    "description": "`flip(A)` reverses the order of elements in `A` along one or more dimensions. With no dimension argument, RunMat (like MATLAB) flips along the first dimension whose extent is greater than one. Positive integer dimensions or dimension vectors allow you to mirror data along any axis, and direction keywords such as `'horizontal'` or `'vertical'` provide a readable alternative to numeric indices.",
+    "behaviors": [
+        "Works for numeric arrays, logical masks, complex arrays, and string or character arrays.",
+        "`flip(A)` locates the first non-singleton dimension and reverses that axis.",
+        "`flip(A, dim)` flips along the dimension `dim` (1-based, MATLAB-compatible).",
+        "`flip(A, dims)` accepts a vector of dimensions, flipping each axis in order.",
+        "Dimension vectors must be numeric row or column vectors of positive integers.",
+        "`flip(A, 'horizontal')` and `flip(A, 'vertical')` map to dimensions 2 and 1 respectively. `'both'` flips along the first two dimensions.",
+        "Dimensions larger than `ndims(A)` are allowed. RunMat pads trailing singleton axes so the request becomes a no-op, matching MATLAB semantics.",
+        "Reversing an empty dimension (extent zero) is a no-op.",
+        "gpuArray inputs stay on the device: the runtime calls provider flip hooks when available and otherwise gathers, flips, and re-uploads the data."
+    ],
+    "examples": [
+        {
+            "description": "Reversing a Row Vector",
+            "input": "row = 1:5;\nrev = flip(row)",
+            "output": "rev = [5 4 3 2 1]"
+        },
+        {
+            "description": "Reversing Matrix Rows (Vertical Flip)",
+            "input": "A = [1 2 3; 4 5 6; 7 8 9];\nB = flip(A)",
+            "output": "B =\n     7     8     9\n     4     5     6\n     1     2     3"
+        },
+        {
+            "description": "Flipping Columns with the Horizontal Direction Keyword",
+            "input": "A = magic(3);\nH = flip(A, 'horizontal')",
+            "output": "H =\n     2     7     6\n     9     5     1\n     4     3     8"
+        },
+        {
+            "description": "Flipping Along Multiple Dimensions",
+            "input": "T = reshape(1:8, [2 2 2]);\nF = flip(T, [1 3])",
+            "output": "F(:,:,1) =\n     3     4\n     1     2\n\nF(:,:,2) =\n     7     8\n     5     6"
+        },
+        {
+            "description": "Flipping Character Data",
+            "input": "C = ['r','u','n'; 'm','a','t'];\nCt = flip(C, 'horizontal')",
+            "output": "Ct =\n    'nur'\n    'tam'"
+        },
+        {
+            "description": "Flipping gpuArray Data While Staying on the Device",
+            "input": "G = gpuArray(rand(4, 4));\nV = flip(G, 'vertical');\nisgpuarray(V)",
+            "output": "ans = logical 1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Which dimension does `flip(A)` use by default?",
+            "answer": "The first dimension whose size is greater than one. Column vectors flip along dimension 1, row vectors flip along dimension 2."
+        },
+        {
+            "question": "What happens if I pass a dimension larger than `ndims(A)`?",
+            "answer": "Nothing changes; RunMat pads missing axes with singleton dimensions, so the flip becomes a no-op, just like MATLAB."
+        },
+        {
+            "question": "Do direction keywords work with any array type?",
+            "answer": "Yes. `'horizontal'` maps to dimension 2, `'vertical'` to dimension 1, and `'both'` applies both flips in sequence."
+        },
+        {
+            "question": "Can I flip logical or string arrays?",
+            "answer": "Absolutely. Logical results stay logical, and string arrays preserve string elements while reordering their positions."
+        },
+        {
+            "question": "Does flipping modify gpuArray data in place?",
+            "answer": "No. The builtin returns a new gpuArray handle. Providers may recycle buffers, but the original value remains unchanged."
+        },
+        {
+            "question": "What about complex inputs?",
+            "answer": "Complex scalars and arrays are reversed just like real data. Scalars remain complex scalars after the operation."
+        }
+    ],
+    "links": [
+        {
+            "label": "`flipud`",
+            "url": "./flipud"
+        },
+        {
+            "label": "`permute`",
+            "url": "./permute"
+        },
+        {
+            "label": "`ipermute`",
+            "url": "./ipermute"
+        },
+        {
+            "label": "`repmat`",
+            "url": "./repmat"
+        },
+        {
+            "label": "`gpuArray`",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "`gather`",
+            "url": "./gather"
+        },
+        {
+            "label": "cat",
+            "url": "./cat"
+        },
+        {
+            "label": "circshift",
+            "url": "./circshift"
+        },
+        {
+            "label": "diag",
+            "url": "./diag"
+        },
+        {
+            "label": "fliplr",
+            "url": "./fliplr"
+        },
+        {
+            "label": "horzcat",
+            "url": "./horzcat"
+        },
+        {
+            "label": "kron",
+            "url": "./kron"
+        },
+        {
+            "label": "reshape",
+            "url": "./reshape"
+        },
+        {
+            "label": "rot90",
+            "url": "./rot90"
+        },
+        {
+            "label": "squeeze",
+            "url": "./squeeze"
+        },
+        {
+            "label": "tril",
+            "url": "./tril"
+        },
+        {
+            "label": "triu",
+            "url": "./triu"
+        },
+        {
+            "label": "vertcat",
+            "url": "./vertcat"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/shape/flip.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/shape/flip.rs"
+    },
+    "gpu_residency": "No additional steps are required. RunMat keeps tensors on the GPU across fused expressions. You can opt-in explicitly with `gpuArray` for MATLAB compatibility, but the auto-offload planner already tracks residency and minimises host/device copies even when a provider falls back to the gather → flip → upload pathway.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active, the runtime first checks whether the selected provider implements the `flip` hook (`ProviderHook::Custom(\"flip\")`). Providers may specialise the operation using device-side kernels. If the hook is missing (common for the simple provider or builds without GPU support), RunMat gathers the tensor once, performs the flip on the host, and uploads the result back to the device. The returned value is still a gpuArray, ensuring residency is preserved for downstream fused expressions."
+    ],
+    "key": "flip",
+    "slug": "flip",
+    "categoryPath": [
+        "array",
+        "shape"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=flip.js.map

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

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

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

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

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

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

package/dist/generated/builtins/fliplr.js

@@ -0,0 +1,202 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "fliplr",
+    "category": "array/shape",
+    "keywords": [
+        "fliplr",
+        "flip",
+        "horizontal",
+        "matrix",
+        "gpu"
+    ],
+    "summary": "Flip an array left-to-right along the second dimension.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64",
+            "i32",
+            "bool"
+        ],
+        "broadcasting": "none",
+        "notes": "Uses the generic flip provider hook with axis=1; falls back to gather→flip→upload when unavailable."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::shape::fliplr::tests",
+        "integration": "["
+    },
+    "description": "`fliplr(A)` mirrors `A` across its vertical axis, reversing the column order (dimension 2). It accepts scalars, vectors, matrices, N-D tensors, logical arrays, character arrays, string arrays, complex data, and gpuArray handles, matching MATLAB semantics.",
+    "behaviors": [
+        "Always reverses dimension 2 (columns) and leaves all other dimensions untouched, even for rank > 2 data.",
+        "Inputs with fewer than two columns (column vectors, scalars) are returned unchanged because the second dimension is singleton.",
+        "Logical, numeric, complex, character, and string arrays all preserve their MATLAB types and storage layout.",
+        "gpuArray inputs execute on the device via the generic `flip` provider hook (axis = 1); when that hook is missing, RunMat gathers once, mirrors the data on the host, and uploads the result so the returned value is still a gpuArray.",
+        "Dimensions larger than `ndims(A)` are treated as singleton axes, so `fliplr` never errors when `A` has rank < 2."
+    ],
+    "examples": [
+        {
+            "description": "Reverse Columns of a Matrix",
+            "input": "A = [1 2 3; 4 5 6];\nB = fliplr(A)",
+            "output": "B =\n     3     2     1\n     6     5     4"
+        },
+        {
+            "description": "Mirror an Image Matrix Horizontally",
+            "input": "img = reshape(1:16, 4, 4);\nmirrored = fliplr(img)",
+            "output": "mirrored =\n    4     3     2     1\n    8     7     6     5\n   12    11    10     9\n   16    15    14    13"
+        },
+        {
+            "description": "Flip the Order of Polynomial Coefficients",
+            "input": "c = [1 0 -2 5];\nrev = fliplr(c)",
+            "output": "rev = [5  -2  0  1]"
+        },
+        {
+            "description": "Reverse Each Slice in a 3-D Array Along Columns",
+            "input": "T = reshape(1:24, [3 4 2]);\nF = fliplr(T)",
+            "output": "F(:,:,1) =\n     4     3     2     1\n     8     7     6     5\n    12    11    10     9\n\nF(:,:,2) =\n    16    15    14    13\n    20    19    18    17\n    24    23    22    21"
+        },
+        {
+            "description": "Preserve Column Vector Orientation",
+            "input": "col = (1:4)';\nsame = fliplr(col)",
+            "output": "same =\n     1\n     2\n     3\n     4"
+        },
+        {
+            "description": "Flip Characters in a Two-Row Char Array",
+            "input": "C = ['r','u','n'; 'm','a','t'];\nCt = fliplr(C)",
+            "output": "Ct =\n    'nur'\n    'tam'"
+        },
+        {
+            "description": "Keep gpuArray Results on the Device While Flipping Columns",
+            "input": "G = gpuArray(rand(8, 8));\nH = fliplr(G)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `fliplr` change column vectors?",
+            "answer": "No. A column vector has a singleton second dimension, so reversing that axis leaves the data unchanged."
+        },
+        {
+            "question": "Is `fliplr` the same as calling `flip(A, 2)`?",
+            "answer": "Yes. `fliplr` is a convenience wrapper around `flip` that always targets dimension 2 (columns)."
+        },
+        {
+            "question": "Can I apply `fliplr` to N-D tensors?",
+            "answer": "Absolutely. Only dimension 2 is reversed; all other axes keep their original order regardless of rank."
+        },
+        {
+            "question": "Does `fliplr` support string and character arrays?",
+            "answer": "Yes. String arrays reorder their elements, and character arrays mirror each row while preserving UTF-8 data."
+        },
+        {
+            "question": "What happens on the GPU if there is no flip kernel?",
+            "answer": "RunMat gathers the tensor once, mirrors it on the CPU, and uploads the result so you still receive a gpuArray."
+        },
+        {
+            "question": "Does `fliplr` allocate new GPU buffers?",
+            "answer": "Providers may reuse storage, but the builtin always returns a fresh handle. The simple provider uploads a new buffer."
+        },
+        {
+            "question": "Is `fliplr` numerically stable?",
+            "answer": "Yes. The function only reorders elements; values are never modified, so it is numerically stable."
+        }
+    ],
+    "links": [
+        {
+            "label": "`flip`",
+            "url": "./flip"
+        },
+        {
+            "label": "`flipud`",
+            "url": "./flipud"
+        },
+        {
+            "label": "`permute`",
+            "url": "./permute"
+        },
+        {
+            "label": "`reshape`",
+            "url": "./reshape"
+        },
+        {
+            "label": "`gpuArray`",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "`gather`",
+            "url": "./gather"
+        },
+        {
+            "label": "cat",
+            "url": "./cat"
+        },
+        {
+            "label": "circshift",
+            "url": "./circshift"
+        },
+        {
+            "label": "diag",
+            "url": "./diag"
+        },
+        {
+            "label": "horzcat",
+            "url": "./horzcat"
+        },
+        {
+            "label": "ipermute",
+            "url": "./ipermute"
+        },
+        {
+            "label": "kron",
+            "url": "./kron"
+        },
+        {
+            "label": "repmat",
+            "url": "./repmat"
+        },
+        {
+            "label": "rot90",
+            "url": "./rot90"
+        },
+        {
+            "label": "squeeze",
+            "url": "./squeeze"
+        },
+        {
+            "label": "tril",
+            "url": "./tril"
+        },
+        {
+            "label": "triu",
+            "url": "./triu"
+        },
+        {
+            "label": "vertcat",
+            "url": "./vertcat"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/shape/fliplr.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/shape/fliplr.rs"
+    },
+    "gpu_residency": "You typically do not need to call `gpuArray` directly. RunMat’s auto-offload planner keeps tensors on the GPU when profitable and only gathers when a provider lacks the flip hook. Even in that fallback, `fliplr` uploads the flipped result back to the device so subsequent operations can stay gpu-resident.",
+    "gpu_behavior": [
+        "RunMat first tries to execute `fliplr` on the GPU by delegating to the provider’s generic `flip` implementation with axis `1` (zero-based). If the provider does not implement this hook, RunMat transparently gathers the tensor, performs the horizontal flip on the host, and uploads the result back to the device so residency is preserved."
+    ],
+    "key": "fliplr",
+    "slug": "fliplr",
+    "categoryPath": [
+        "array",
+        "shape"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=fliplr.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fliplr.js","sourceRoot":"","sources":["../../../src/generated/builtins/fliplr.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,QAAQ;QACR,MAAM;QACN,YAAY;QACZ,QAAQ;QACR,KAAK;KACN;IACD,SAAS,EAAE,yDAAyD;IACpE,YAAY,EAAE,EAAE;IAChB,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;YACL,KAAK;YACL,MAAM;SACP;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,qGAAqG;KAC/G;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,uCAAuC;QAC/C,aAAa,EAAE,GAAG;KACnB;IACD,aAAa,EAAE,iQAAiQ;IAChR,WAAW,EAAE;QACX,0GAA0G;QAC1G,gIAAgI;QAChI,6GAA6G;QAC7G,wOAAwO;QACxO,kHAAkH;KACnH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,oCAAoC;YAC7C,QAAQ,EAAE,6CAA6C;SACxD;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,oDAAoD;YAC7D,QAAQ,EAAE,gHAAgH;SAC3H;QACD;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,kCAAkC;YAC3C,QAAQ,EAAE,qBAAqB;SAChC;QACD;YACE,aAAa,EAAE,iDAAiD;YAChE,OAAO,EAAE,4CAA4C;YACrD,QAAQ,EAAE,sLAAsL;SACjM;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,mCAAmC;YAC5C,QAAQ,EAAE,wCAAwC;SACnD;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,iDAAiD;YAC1D,QAAQ,EAAE,4BAA4B;SACvC;QACD;YACE,aAAa,EAAE,4DAA4D;YAC3E,OAAO,EAAE,0CAA0C;SACpD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,yGAAyG;SACpH;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,iGAAiG;SAC5G;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,wGAAwG;SACnH;QACD;YACE,UAAU,EAAE,oDAAoD;YAChE,QAAQ,EAAE,8GAA8G;SACzH;QACD;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,gHAAgH;SAC3H;QACD;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,uHAAuH;SAClI;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,mGAAmG;SAC9G;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,4DAA4D;QACrE,KAAK,EAAE,yGAAyG;KACjH;IACD,eAAe,EAAE,mTAAmT;IACpU,cAAc,EAAE;QACd,mVAAmV;KACpV;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,cAAc,EAAE;QACd,OAAO;QACP,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/flipud.js

@@ -0,0 +1,198 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "flipud",
+    "category": "array/shape",
+    "keywords": [
+        "flipud",
+        "flip",
+        "vertical",
+        "matrix",
+        "gpu"
+    ],
+    "summary": "Flip an array up-to-down along the first dimension.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64",
+            "i32",
+            "bool"
+        ],
+        "broadcasting": "none",
+        "notes": "Uses the generic flip provider hook with axis=0; falls back to gather→flip→upload when unavailable."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::shape::flipud::tests",
+        "integration": "["
+    },
+    "description": "`flipud(A)` mirrors `A` across its horizontal axis, reversing the order of rows (dimension 1). It works with scalars, vectors, matrices, N-D tensors, logical arrays, character arrays, string arrays, cell arrays, complex data, and gpuArray handles, matching MATLAB semantics.",
+    "behaviors": [
+        "Always reverses dimension 1 (rows) and leaves all other dimensions untouched, even for rank > 2 data.",
+        "Inputs with a single row (row vectors, scalars) are returned unchanged because the first dimension is singleton.",
+        "Numeric, logical, complex, character, string, and cell arrays all retain their MATLAB types, layout, and metadata (including UTF-16 code units for char arrays).",
+        "gpuArray inputs execute on the device via the generic `flip` provider hook (axis = 0); when that hook is unavailable, RunMat gathers once, mirrors the data on the host, and uploads the result so the returned value is still a gpuArray.",
+        "Dimensions larger than `ndims(A)` are treated as singleton axes, so `flipud` never errors when `A` has rank < 1.",
+        "Behaviour matches `flip(A, 1)` exactly; `flipud` is provided for readability and compatibility with existing MATLAB code."
+    ],
+    "examples": [
+        {
+            "description": "Reverse Rows of a Matrix",
+            "input": "A = [1 2 3; 4 5 6; 7 8 9];\nB = flipud(A)",
+            "output": "B =\n     7     8     9\n     4     5     6\n     1     2     3"
+        },
+        {
+            "description": "Reverse a Column Vector",
+            "input": "col = (1:4)';\nrev = flipud(col)",
+            "output": "rev =\n     4\n     3\n     2\n     1"
+        },
+        {
+            "description": "Flip the First Dimension of a 3-D Tensor",
+            "input": "T = reshape(1:24, [3 4 2]);\nF = flipud(T)",
+            "output": "F(:,:,1) =\n     3     6     9    12\n     2     5     8    11\n     1     4     7    10\n\nF(:,:,2) =\n    15    18    21    24\n    14    17    20    23\n    13    16    19    22"
+        },
+        {
+            "description": "Flip Characters in a Char Array Vertically",
+            "input": "C = ['run'; 'mat'];\nCv = flipud(C)",
+            "output": "Cv =\n    'mat'\n    'run'"
+        },
+        {
+            "description": "Preserve Row Vector Orientation",
+            "input": "row = 1:5;\nsame = flipud(row)",
+            "output": "same = [1 2 3 4 5]"
+        },
+        {
+            "description": "Keep gpuArray Results on the Device While Flipping Rows",
+            "input": "G = gpuArray(rand(8, 8));\nH = flipud(G);\nisequal(gather(H), flipud(gather(G)))   % illustrative verification"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `flipud` change row vectors?",
+            "answer": "No. A row vector has a singleton first dimension, so reversing that axis leaves the data unchanged."
+        },
+        {
+            "question": "Is `flipud` the same as calling `flip(A, 1)`?",
+            "answer": "Yes. `flipud` is a convenience wrapper around `flip` that always targets dimension&nbsp;1 (rows)."
+        },
+        {
+            "question": "Can I apply `flipud` to N-D tensors?",
+            "answer": "Absolutely. Only dimension&nbsp;1 is reversed; all other axes keep their original order regardless of rank."
+        },
+        {
+            "question": "Does `flipud` support string, character, and cell arrays?",
+            "answer": "Yes. String arrays reorder their elements, character arrays mirror each column while preserving UTF-8 data, and cell arrays reverse their rows without copying contained values."
+        },
+        {
+            "question": "What happens on the GPU if there is no flip kernel?",
+            "answer": "RunMat gathers the tensor once, mirrors it on the CPU, and uploads the result so you still receive a gpuArray."
+        },
+        {
+            "question": "Does `flipud` allocate new GPU buffers?",
+            "answer": "Providers may reuse storage, but the builtin always returns a fresh handle. The simple provider uploads a new buffer."
+        },
+        {
+            "question": "Is `flipud` numerically stable?",
+            "answer": "Yes. The function only reorders elements; values are never modified, so it is numerically stable."
+        }
+    ],
+    "links": [
+        {
+            "label": "`flip`",
+            "url": "./flip"
+        },
+        {
+            "label": "`fliplr`",
+            "url": "./fliplr"
+        },
+        {
+            "label": "`permute`",
+            "url": "./permute"
+        },
+        {
+            "label": "`reshape`",
+            "url": "./reshape"
+        },
+        {
+            "label": "`gpuArray`",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "`gather`",
+            "url": "./gather"
+        },
+        {
+            "label": "cat",
+            "url": "./cat"
+        },
+        {
+            "label": "circshift",
+            "url": "./circshift"
+        },
+        {
+            "label": "diag",
+            "url": "./diag"
+        },
+        {
+            "label": "horzcat",
+            "url": "./horzcat"
+        },
+        {
+            "label": "ipermute",
+            "url": "./ipermute"
+        },
+        {
+            "label": "kron",
+            "url": "./kron"
+        },
+        {
+            "label": "repmat",
+            "url": "./repmat"
+        },
+        {
+            "label": "rot90",
+            "url": "./rot90"
+        },
+        {
+            "label": "squeeze",
+            "url": "./squeeze"
+        },
+        {
+            "label": "tril",
+            "url": "./tril"
+        },
+        {
+            "label": "triu",
+            "url": "./triu"
+        },
+        {
+            "label": "vertcat",
+            "url": "./vertcat"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/shape/flipud.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/shape/flipud.rs"
+    },
+    "gpu_residency": "You typically do not need to call `gpuArray` directly. RunMat’s auto-offload planner keeps tensors on the GPU when profitable and only gathers when a provider lacks the flip hook. Even in that fallback, `flipud` uploads the flipped result back to the device so subsequent operations remain gpu-resident.",
+    "gpu_behavior": [
+        "RunMat first tries to execute `flipud` on the GPU by delegating to the provider’s generic `flip` implementation with axis `0` (zero-based). If the provider does not implement this hook, RunMat transparently gathers the tensor, performs the vertical flip on the host, and uploads the result back to the device so residency is preserved."
+    ],
+    "key": "flipud",
+    "slug": "flipud",
+    "categoryPath": [
+        "array",
+        "shape"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=flipud.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flipud.js","sourceRoot":"","sources":["../../../src/generated/builtins/flipud.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,QAAQ;QACR,MAAM;QACN,UAAU;QACV,QAAQ;QACR,KAAK;KACN;IACD,SAAS,EAAE,qDAAqD;IAChE,YAAY,EAAE,EAAE;IAChB,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;YACL,KAAK;YACL,MAAM;SACP;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,qGAAqG;KAC/G;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,uCAAuC;QAC/C,aAAa,EAAE,GAAG;KACnB;IACD,aAAa,EAAE,yRAAyR;IACxS,WAAW,EAAE;QACX,4GAA4G;QAC5G,kHAAkH;QAClH,kKAAkK;QAClK,4OAA4O;QAC5O,kHAAkH;QAClH,2HAA2H;KAC5H;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,0BAA0B;YACzC,OAAO,EAAE,2CAA2C;YACpD,QAAQ,EAAE,iEAAiE;SAC5E;QACD;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,kCAAkC;YAC3C,QAAQ,EAAE,uCAAuC;SAClD;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,4CAA4C;YACrD,QAAQ,EAAE,sLAAsL;SACjM;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,qCAAqC;YAC9C,QAAQ,EAAE,4BAA4B;SACvC;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,gCAAgC;YACzC,QAAQ,EAAE,oBAAoB;SAC/B;QACD;YACE,aAAa,EAAE,yDAAyD;YACxE,OAAO,EAAE,gHAAgH;SAC1H;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,qGAAqG;SAChH;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,mGAAmG;SAC9G;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,6GAA6G;SACxH;QACD;YACE,UAAU,EAAE,2DAA2D;YACvE,QAAQ,EAAE,kLAAkL;SAC7L;QACD;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,gHAAgH;SAC3H;QACD;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,uHAAuH;SAClI;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,mGAAmG;SAC9G;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,4DAA4D;QACrE,KAAK,EAAE,yGAAyG;KACjH;IACD,eAAe,EAAE,iTAAiT;IAClU,cAAc,EAAE;QACd,iVAAiV;KAClV;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,cAAc,EAAE;QACd,OAAO;QACP,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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