runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/ifftshift.js

@@ -0,0 +1,141 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "ifftshift",
+    "category": "math/fft",
+    "keywords": [
+        "ifftshift",
+        "inverse fft shift",
+        "frequency alignment",
+        "gpu"
+    ],
+    "summary": "Undo fftshift by moving the zero-frequency component back to the origin.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Uses provider circshift hooks when available; otherwise gathers, reorders on the host, and uploads again."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::fft::ifftshift::tests",
+        "integration": "builtins::math::fft::ifftshift::tests::ifftshift_gpu_roundtrip"
+    },
+    "description": "`ifftshift(X)` circularly shifts data so that the DC (zero-frequency) component returns to index 1 along each transformed dimension. It is the inverse of `fftshift` and is commonly used immediately before calling `ifft`.",
+    "behaviors": [
+        "When no dimensions are specified, every axis is shifted by `ceil(size(X, dim) / 2)`.",
+        "Passing a list of dimensions restricts shifting to those axes; zeros and ones are treated as no-ops.",
+        "Odd-length dimensions shift by one additional element compared with `fftshift`, matching MATLAB's `ifftshift` parity rules.",
+        "Works for real, complex, logical, and GPU-resident tensors.",
+        "Empty arrays and scalars are returned unchanged."
+    ],
+    "examples": [
+        {
+            "description": "Undoing fftshift on an even-length spectrum",
+            "input": "x = 0:7;\ny = ifftshift(x)",
+            "output": "y = [4 5 6 7 0 1 2 3]"
+        },
+        {
+            "description": "Undoing fftshift on an odd-length spectrum",
+            "input": "x = 1:5;\ny = ifftshift(x)",
+            "output": "y = [3 4 5 1 2]"
+        },
+        {
+            "description": "Preparing data for inverse FFT",
+            "input": "fx = fft(rand(1, 8));\ncentered = fftshift(fx);\nrestored = ifftshift(centered);\nsignal = ifft(restored)"
+        },
+        {
+            "description": "Shifting only selected dimensions",
+            "input": "A = reshape(1:12, 3, 4);\nrowsShifted = ifftshift(A, 1);   % shift rows only\ncolsShifted = ifftshift(A, 2);   % shift columns only",
+            "output": "rowsShifted =\n     2     5     8    11\n     3     6     9    12\n     1     4     7    10\n\ncolsShifted =\n     7    10     1     4\n     8    11     2     5\n     9    12     3     6"
+        },
+        {
+            "description": "Using ifftshift with gpuArray data",
+            "input": "G = gpuArray(0:7);\nshifted = ifftshift(G);\nhost = gather(shifted)",
+            "output": "host = [4 5 6 7 0 1 2 3]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I call `ifftshift`?",
+            "answer": "Call `ifftshift` right before `ifft` (or `ifftn`) after you have applied `fftshift`-based processing in the frequency domain. It restores the DC component to index 1."
+        },
+        {
+            "question": "Is `ifftshift` always the inverse of `fftshift`?",
+            "answer": "Yes. For any supported input, `ifftshift(fftshift(X))` returns `X`, including odd-length dimensions where the shift counts differ."
+        },
+        {
+            "question": "Does `ifftshift` modify data values?",
+            "answer": "No. It only reorders elements. Magnitudes, phases, and overall content stay the same."
+        },
+        {
+            "question": "Can I restrict `ifftshift` to specific axes?",
+            "answer": "Yes. Pass a dimension index, vector of indices, or logical mask exactly like in MATLAB."
+        },
+        {
+            "question": "Does `ifftshift` support gpuArray inputs?",
+            "answer": "Yes. RunMat keeps GPU data on-device whenever possible and falls back to a single gather/upload cycle otherwise."
+        }
+    ],
+    "links": [
+        {
+            "label": "fftshift",
+            "url": "./fftshift"
+        },
+        {
+            "label": "fft",
+            "url": "./fft"
+        },
+        {
+            "label": "ifft",
+            "url": "./ifft"
+        },
+        {
+            "label": "circshift",
+            "url": "./circshift"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "fft2",
+            "url": "./fft2"
+        },
+        {
+            "label": "ifft2",
+            "url": "./ifft2"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/fft/ifftshift.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/fft/ifftshift.rs"
+    },
+    "gpu_residency": "You can rely on RunMat's auto-offload to keep FFT data on the GPU. When a provider exposes `circshift`, `ifftshift` executes entirely on the device and the result remains GPU-resident. If no provider is registered—or it lacks `circshift`—RunMat gathers once, applies the host reorder, and uploads the result so the rest of the computation can still run accelerated. You can call `gpuArray` explicitly when you need MATLAB parity or to enforce a residency boundary.",
+    "gpu_behavior": [
+        "RunMat first attempts to execute the shift entirely on the GPU using the provider's `circshift` hook. If that is unavailable, RunMat gathers the data exactly once, performs the reorder on the host, and uploads the result so downstream computations can continue on the device. Scalars remain on their current device to avoid unnecessary transfers."
+    ],
+    "key": "ifftshift",
+    "slug": "ifftshift",
+    "categoryPath": [
+        "math",
+        "fft"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=ifftshift.js.map

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

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

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

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

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

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

package/dist/generated/builtins/imag.js

@@ -0,0 +1,223 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "imag",
+    "category": "math/elementwise",
+    "keywords": [
+        "imag",
+        "imaginary",
+        "complex",
+        "elementwise",
+        "gpu"
+    ],
+    "summary": "Extract the imaginary component of scalars, vectors, matrices, or N-D tensors.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Falls back to the host when the active provider lacks unary_imag or when inputs require host-only conversions (complex tensors, characters)."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::elementwise::imag::tests",
+        "integration": "builtins::math::elementwise::imag::tests::imag_gpu_provider_roundtrip"
+    },
+    "description": "`imag(x)` returns the imaginary component of every element in `x`. Complex inputs yield their imaginary part, while real inputs produce zero-valued results of matching shape.",
+    "behaviors": [
+        "Complex scalars, vectors, matrices, and higher-dimensional tensors return only their imaginary components.",
+        "Purely real inputs (double, single, logical) produce zeros of type double that match the input size.",
+        "Character arrays are converted to double and therefore produce zero-filled numeric arrays of the same size.",
+        "String arrays are unsupported and raise an error (`imag` expects numeric, logical, or character data).",
+        "Sparse arrays are currently densified; native sparse support is planned."
+    ],
+    "examples": [
+        {
+            "description": "Extracting the imaginary part of a complex scalar",
+            "input": "z = 3 + 4i;\nb = imag(z)",
+            "output": "b = 4"
+        },
+        {
+            "description": "Retrieving imaginary components of a complex matrix",
+            "input": "Z = [1+2i 4-3i; -5+0i 7+8i];\nY = imag(Z)",
+            "output": "Y =\n     2    -3\n     0     8"
+        },
+        {
+            "description": "Verifying that real inputs yield zero",
+            "input": "data = [-2.5 0 9.75];\nvalues = imag(data)",
+            "output": "values = [0 0 0]"
+        },
+        {
+            "description": "Imaginary part of logical masks",
+            "input": "mask = logical([0 1 0; 1 0 1]);\nzerosOnly = imag(mask)",
+            "output": "zerosOnly =\n     0     0     0\n     0     0     0"
+        },
+        {
+            "description": "Working with GPU-resident tensors",
+            "input": "G = rand(2048, 256, \"gpuArray\");\nres = imag(G)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `imag` modify purely real inputs?",
+            "answer": "No. Purely real, logical, and character inputs become zero-valued doubles of the same size."
+        },
+        {
+            "question": "How does `imag` handle complex zeros?",
+            "answer": "`imag(0 + 0i)` returns exactly `0`. Imaginary zeros are preserved."
+        },
+        {
+            "question": "Can I call `imag` on string arrays?",
+            "answer": "No. Like MATLAB, `imag` only accepts numeric, logical, or character arrays. Convert strings with `double(string)` first if you require numeric codes."
+        },
+        {
+            "question": "Does `imag` allocate a new array?",
+            "answer": "Yes, in line with MATLAB semantics. Fusion may eliminate the allocation when the surrounding expression can be fused safely."
+        },
+        {
+            "question": "What happens on the GPU without `unary_imag`?",
+            "answer": "RunMat gathers the tensor to host memory, applies the CPU semantics (producing zeros or extracting complex components), and allows subsequent operations to re-upload the data if doing so is worthwhile."
+        },
+        {
+            "question": "Is GPU execution numerically identical to CPU?",
+            "answer": "Yes. For real tensors the result is exactly zero; for complex tensors the CPU path matches MATLAB's behaviour."
+        },
+        {
+            "question": "Does `imag` participate in fusion?",
+            "answer": "Yes. The fusion planner can fold `imag` into neighbouring elementwise kernels, letting providers keep tensors on the GPU whenever possible."
+        }
+    ],
+    "links": [
+        {
+            "label": "real",
+            "url": "./real"
+        },
+        {
+            "label": "abs",
+            "url": "./abs"
+        },
+        {
+            "label": "sign",
+            "url": "./sign"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "angle",
+            "url": "./angle"
+        },
+        {
+            "label": "conj",
+            "url": "./conj"
+        },
+        {
+            "label": "double",
+            "url": "./double"
+        },
+        {
+            "label": "exp",
+            "url": "./exp"
+        },
+        {
+            "label": "expm1",
+            "url": "./expm1"
+        },
+        {
+            "label": "factorial",
+            "url": "./factorial"
+        },
+        {
+            "label": "gamma",
+            "url": "./gamma"
+        },
+        {
+            "label": "hypot",
+            "url": "./hypot"
+        },
+        {
+            "label": "ldivide",
+            "url": "./ldivide"
+        },
+        {
+            "label": "log",
+            "url": "./log"
+        },
+        {
+            "label": "log10",
+            "url": "./log10"
+        },
+        {
+            "label": "log1p",
+            "url": "./log1p"
+        },
+        {
+            "label": "log2",
+            "url": "./log2"
+        },
+        {
+            "label": "minus",
+            "url": "./minus"
+        },
+        {
+            "label": "plus",
+            "url": "./plus"
+        },
+        {
+            "label": "pow2",
+            "url": "./pow2"
+        },
+        {
+            "label": "power",
+            "url": "./power"
+        },
+        {
+            "label": "rdivide",
+            "url": "./rdivide"
+        },
+        {
+            "label": "single",
+            "url": "./single"
+        },
+        {
+            "label": "sqrt",
+            "url": "./sqrt"
+        },
+        {
+            "label": "times",
+            "url": "./times"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/elementwise/imag.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/imag.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. RunMat's fusion planner and Accelerate layer track residency automatically, keeping tensors on the GPU whenever device execution is profitable. Explicit `gpuArray` / `gather` calls remain available for MATLAB compatibility or when you need deterministic residency control (for example, when integrating with custom CUDA or OpenCL kernels).",
+    "gpu_behavior": [
+        "**Hook available:** The provider materialises a zero-filled tensor directly on the GPU without any host transfers.",
+        "**Hook missing or unsupported dtype:** RunMat gathers the tensor to host memory, applies the CPU semantics (including the conversions for logical and character inputs), and resumes execution. Downstream fusion can still re-upload the result when profitable.\n\nComplex GPU tensors are currently gathered to the host because GPU-side complex storage is not yet available; providers can add fused support later without changing this builtin."
+    ],
+    "key": "imag",
+    "slug": "imag",
+    "categoryPath": [
+        "math",
+        "elementwise"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=imag.js.map

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

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

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

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

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

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

package/dist/generated/builtins/image.js

@@ -0,0 +1,98 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "image",
+    "category": "plotting",
+    "keywords": [
+        "image",
+        "image display",
+        "truecolor image",
+        "indexed image",
+        "matlab image",
+        "imshow style image"
+    ],
+    "summary": "Display indexed or truecolor images as graphics objects with MATLAB `image` semantics and GPU-backed rendering paths.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`image` uses the shared image/surface path and supports GPU-backed paths for indexed and truecolor image inputs."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::image::tests",
+        "integration": "runmat-plot/tests/renderer_tests.rs"
+    },
+    "description": "`image` displays indexed or truecolor image data as a plotting object rather than as a detached bitmap. In RunMat it returns an image handle, uses the shared flattened surface/image-mode rendering path, and supports both host and GPU-backed truecolor or indexed-image workflows while preserving MATLAB `image` semantics around graphics-object behavior and axes placement.",
+    "behaviors": [
+        "`image(C)` displays image data using implicit axes; `image(X, Y, C)` places the image explicitly on the target axes.",
+        "Indexed images and truecolor images both use the shared surface/image rendering architecture.",
+        "The returned value is an image-handle object that works with `get` and `set`.",
+        "`image` is object-oriented and placement-oriented; use `imagesc` when you specifically want scaled matrix visualization with color mapping semantics.",
+        "Dedicated GPU-backed paths cover both indexed and truecolor image inputs when plotting-compatible buffers are available."
+    ],
+    "examples": [
+        {
+            "description": "Display a simple indexed image",
+            "input": "C = [1 2 3; 3 2 1; 2 3 1];\nimage(C);\ncolormap('jet');"
+        },
+        {
+            "description": "Display a truecolor RGB image",
+            "input": "img = zeros(100, 100, 3);\nimg(:,:,1) = 1;\nimg(25:75,25:75,2) = 1;\nimage(img);",
+            "output": "% Displays a truecolor image object"
+        },
+        {
+            "description": "Position an image explicitly on axes and inspect the handle",
+            "input": "C = reshape(1:16, 4, 4);\nh = image([0 3], [10 40], C);\nget(h, 'Type')",
+            "output": "ans =\n    'image'"
+        }
+    ],
+    "links": [
+        {
+            "label": "imagesc",
+            "url": "./imagesc"
+        },
+        {
+            "label": "colormap",
+            "url": "./colormap"
+        },
+        {
+            "label": "colorbar",
+            "url": "./colorbar"
+        },
+        {
+            "label": "get",
+            "url": "./get"
+        },
+        {
+            "label": "set",
+            "url": "./set"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/image.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/image.rs"
+    },
+    "gpu_residency": "`image` preserves GPU residency when the image pipeline can consume exported indexed or truecolor image buffers directly. If the active combination cannot stay on the direct path, RunMat gathers once and renders the same image-object semantics on the fallback path.",
+    "gpu_behavior": [
+        "Indexed images and truecolor images both have dedicated GPU-aware rendering paths in the image stack.",
+        "Image handle behavior, axes placement, and replay/export semantics remain aligned across GPU and fallback paths."
+    ],
+    "key": "image",
+    "slug": "image",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=image.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"image.js","sourceRoot":"","sources":["../../../src/generated/builtins/image.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,OAAO;QACP,eAAe;QACf,iBAAiB;QACjB,eAAe;QACf,cAAc;QACd,oBAAoB;KACrB;IACD,SAAS,EAAE,uHAAuH;IAClI,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,QAAQ;YACR,QAAQ;SACT;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,kHAAkH;KAC5H;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,kCAAkC;QAC1C,aAAa,EAAE,qCAAqC;KACrD;IACD,aAAa,EAAE,qXAAqX;IACpY,WAAW,EAAE;QACX,sHAAsH;QACtH,+FAA+F;QAC/F,+EAA+E;QAC/E,uJAAuJ;QACvJ,0HAA0H;KAC3H;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,yDAAyD;SACnE;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,kFAAkF;YAC3F,QAAQ,EAAE,qCAAqC;SAChD;QACD;YACE,aAAa,EAAE,6DAA6D;YAC5E,OAAO,EAAE,yEAAyE;YAClF,QAAQ,EAAE,oBAAoB;SAC/B;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,4DAA4D;QACrE,KAAK,EAAE,yGAAyG;KACjH;IACD,eAAe,EAAE,2QAA2Q;IAC5R,cAAc,EAAE;QACd,uGAAuG;QACvG,kHAAkH;KACnH;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/imagesc.js

@@ -0,0 +1,87 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "imagesc",
+    "category": "plotting",
+    "keywords": [
+        "imagesc",
+        "scaled image",
+        "heatmap",
+        "matrix visualization",
+        "matlab imagesc",
+        "colormap image"
+    ],
+    "summary": "Display scaled matrix images for heatmaps, colormaps, and MATLAB `imagesc` style visualization.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`imagesc` uses the same modern image/surface path as `image`, but applies scaled color-mapped visualization semantics for matrix data."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::imagesc::tests",
+        "integration": "runmat-plot/tests/renderer_tests.rs"
+    },
+    "description": "`imagesc` is the scaled-image member of the modern image family. In RunMat it is ideal for matrix heatmaps and value-driven raster visualization because the matrix is interpreted through colormap and color-limit semantics rather than through direct truecolor object semantics. The returned handle is still an image-handle object, but the visual meaning differs from `image` because `imagesc` is specifically about scaled matrix visualization.",
+    "behaviors": [
+        "`imagesc(C)` displays a matrix using implicit axes and scaled color mapping.",
+        "`imagesc(X, Y, C)` places the scaled image explicitly on the axes using the provided coordinate extents.",
+        "Unlike `image`, `imagesc` is fundamentally about colormap-driven value visualization rather than direct indexed/truecolor graphics-object placement.",
+        "The returned value is still an image-handle object in the shared plotting handle system.",
+        "`imagesc` works naturally with `colormap`, `colorbar`, `caxis`, and subplot-local axes state."
+    ],
+    "examples": [
+        {
+            "description": "Display a matrix as a heatmap-style scaled image",
+            "input": "[X, Y] = meshgrid(linspace(-3, 3, 60), linspace(-3, 3, 60));\nA = sin(X) .* cos(Y);\nimagesc(A);\ncolorbar;"
+        },
+        {
+            "description": "Place a scaled image on explicit axes",
+            "input": "A = reshape(1:100, 10, 10);\nimagesc([-5 5], [0 1], A);\ncolormap('parula');"
+        },
+        {
+            "description": "Use subplot-local color workflows",
+            "input": "[X, Y] = meshgrid(linspace(-3, 3, 40), linspace(-3, 3, 40));\nZ = sin(X) .* cos(Y);\nsubplot(1, 2, 1);\nimagesc(Z);\ncolormap('jet');\ncolorbar;\nsubplot(1, 2, 2);\nimagesc(magic(20));\ncolormap('gray');"
+        }
+    ],
+    "links": [
+        {
+            "label": "image",
+            "url": "./image"
+        },
+        {
+            "label": "colorbar",
+            "url": "./colorbar"
+        },
+        {
+            "label": "colormap",
+            "url": "./colormap"
+        },
+        {
+            "label": "axis",
+            "url": "./axis"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/imagesc.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/imagesc.rs"
+    },
+    "key": "imagesc",
+    "slug": "imagesc",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=imagesc.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"imagesc.js","sourceRoot":"","sources":["../../../src/generated/builtins/imagesc.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,SAAS;QACT,cAAc;QACd,SAAS;QACT,sBAAsB;QACtB,gBAAgB;QAChB,gBAAgB;KACjB;IACD,SAAS,EAAE,iGAAiG;IAC5G,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,QAAQ;YACR,QAAQ;SACT;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,wIAAwI;KAClJ;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,oCAAoC;QAC5C,aAAa,EAAE,qCAAqC;KACrD;IACD,aAAa,EAAE,4bAA4b;IAC3c,WAAW,EAAE;QACX,8EAA8E;QAC9E,0GAA0G;QAC1G,sJAAsJ;QACtJ,0FAA0F;QAC1F,+FAA+F;KAChG;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,6GAA6G;SACvH;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,8EAA8E;SACxF;QACD;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,6MAA6M;SACvN;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,8DAA8D;QACvE,KAAK,EAAE,2GAA2G;KACnH;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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