runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/contains.js

@@ -0,0 +1,149 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "contains",
+    "category": "strings/search",
+    "keywords": [
+        "contains",
+        "substring",
+        "text search",
+        "ignorecase",
+        "string array"
+    ],
+    "summary": "Determine whether text inputs contain specific patterns with MATLAB-compatible implicit expansion and case handling.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/contains.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "matlab",
+        "notes": "Runs on the CPU; when inputs reside on the GPU RunMat gathers them automatically so behaviour matches MATLAB."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::search::contains::tests",
+        "integration": "builtins::strings::search::contains::tests::contains_cell_array_patterns"
+    },
+    "description": "`contains(str, pattern)` returns a logical result indicating whether each element of `str` contains the corresponding text in `pattern`. The builtin supports string arrays, character vectors/arrays, and cell arrays of character vectors, honouring MATLAB's implicit expansion semantics.",
+    "behaviors": [
+        "Accepts text inputs as string scalars/arrays, character scalars/arrays, or cell arrays of character vectors.",
+        "Accepts patterns in the same formats. Either input may be scalar; when sizes differ MATLAB-style implicit expansion applies.",
+        "Missing string scalars (`<missing>`) never match any pattern.",
+        "Empty pattern values (`\"\"` or `''`) always match non-missing text elements.",
+        "The optional `'IgnoreCase', true|false` name-value pair controls case sensitivity (default is case-sensitive).",
+        "Returns a logical scalar when the broadcasted size is one element, otherwise returns a logical array with the broadcasted shape."
+    ],
+    "examples": [
+        {
+            "description": "Check if a string contains a substring",
+            "input": "tf = contains(\"RunMat Accelerate\", \"Accelerate\")",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "Perform a case-insensitive search",
+            "input": "tf = contains(\"RunMat\", \"run\", 'IgnoreCase', true)",
+            "output": "tf = logical\n   1"
+        },
+        {
+            "description": "Apply a scalar pattern to every element of a string array",
+            "input": "labels = [\"alpha\" \"beta\" \"gamma\"];\ntf = contains(labels, \"a\")",
+            "output": "tf = 1×3 logical array\n   1   1   1"
+        },
+        {
+            "description": "Match element-wise patterns with implicit expansion",
+            "input": "names = [\"hydrogen\"; \"helium\"; \"lithium\"];\npatterns = [\"gen\"; \"ium\"; \"iron\"];\ntf = contains(names, patterns)",
+            "output": "tf = 3×1 logical array\n   1\n   1\n   0"
+        },
+        {
+            "description": "Search a cell array of character vectors",
+            "input": "C = {'Mercury', 'Venus', 'Mars'};\ntf = contains(C, 'us')",
+            "output": "tf = 1×3 logical array\n   0   1   0"
+        },
+        {
+            "description": "Provide multiple patterns as a column vector",
+            "input": "tf = contains(\"saturn\", ['s'; 'n'; 'x'])",
+            "output": "tf = 3×1 logical array\n   1\n   1\n   0"
+        },
+        {
+            "description": "Handle empty and missing text values",
+            "input": "texts = [\"\", \"<missing>\"];\ntf = contains(texts, \"\")",
+            "output": "tf = 1×2 logical array\n   1   0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What types can I pass to `contains`?",
+            "answer": "Use string scalars/arrays, character vectors/arrays, or cell arrays of character vectors for both the text and the pattern. Mixed combinations are accepted, and RunMat performs MATLAB-style implicit expansion when the array sizes differ."
+        },
+        {
+            "question": "How do I ignore letter case?",
+            "answer": "Specify `'IgnoreCase', true` (or `'on'`) after the pattern argument. The option is case-insensitive, so `'ignorecase'` also works. The default is `false`, matching MATLAB."
+        },
+        {
+            "question": "What happens with empty patterns?",
+            "answer": "Empty patterns (`\"\"` or `''`) always match non-missing text elements. When the text element is missing (`<missing>`), the result is `false`."
+        },
+        {
+            "question": "Can I search for multiple patterns at once?",
+            "answer": "Yes. Provide `pattern` as a string array, character array, or cell array of character vectors. RunMat applies implicit expansion so that scalar inputs expand across the other argument automatically."
+        },
+        {
+            "question": "How are missing strings treated?",
+            "answer": "Missing string scalars (displayed as `<missing>`) never match any pattern and produce `false` in the result. Use `ismissing` if you need to separate missing values before calling `contains`."
+        },
+        {
+            "question": "Does `contains` run on the GPU?",
+            "answer": "No. The builtin executes on the CPU. If inputs reside on the GPU (for example, after other accelerated operations), RunMat gathers them automatically so behaviour matches MATLAB."
+        },
+        {
+            "question": "Does `contains` preserve the input shape?",
+            "answer": "Yes. The output is a logical array whose shape is the implicit-expansion result of the input shapes. When the broadcasted shape has exactly one element, the builtin returns a logical scalar."
+        }
+    ],
+    "links": [
+        {
+            "label": "`regexp`",
+            "url": "./regexp"
+        },
+        {
+            "label": "`regexpi`",
+            "url": "./regexpi"
+        },
+        {
+            "label": "endsWith",
+            "url": "./endswith"
+        },
+        {
+            "label": "startsWith",
+            "url": "./startswith"
+        },
+        {
+            "label": "strfind",
+            "url": "./strfind"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/search/contains.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/search/contains.rs"
+    },
+    "gpu_residency": "You usually do NOT need to call `gpuArray` yourself in RunMat (unlike MATLAB).\n\n`contains` always executes on the host, but RunMat's runtime automatically gathers any GPU-resident inputs before evaluating the text search so behaviour is identical to MATLAB. You can still call `gpuArray` manually for compatibility with legacy MATLAB code; the runtime will gather those inputs just in time when `contains` runs.",
+    "gpu_behavior": [
+        "`contains` performs host-side text comparisons. When invoked with data that currently resides on the GPU, RunMat gathers the inputs before executing the search so that results match MATLAB exactly. No provider hooks are required for this builtin."
+    ],
+    "key": "contains",
+    "slug": "contains",
+    "categoryPath": [
+        "strings",
+        "search"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=contains.js.map

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

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

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

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

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

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

package/dist/generated/builtins/contour.js

@@ -0,0 +1,96 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "contour",
+    "category": "plotting",
+    "keywords": [
+        "contour",
+        "contour lines",
+        "iso-lines",
+        "level sets",
+        "matlab contour",
+        "topographic lines"
+    ],
+    "summary": "Create contour line plots for level sets, iso-lines, and MATLAB `contour` workflows.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`contour` uses the shared contour-generation path and returns a contour handle in the plotting object model."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::contour::tests"
+    },
+    "description": "`contour` creates contour line plots from scalar fields. In RunMat it returns a contour handle, supports MATLAB-style level-list and level-step workflows, and uses the shared contour-generation pipeline. It is the line-oriented member of the contour family, while `contourf` is the filled-region counterpart.",
+    "behaviors": [
+        "`contour(Z)` uses implicit axes, while `contour(X, Y, Z)` accepts explicit vector or matrix coordinates.",
+        "The builtin returns a contour handle that works with the plotting property system.",
+        "Levels can be controlled through explicit level lists, level counts, or level-step workflows.",
+        "Contour state is subplot-local and composes naturally with `colormap`, `colorbar`, and surface/composite builtins.",
+        "GPU-aware contour generation is used when the shared plotting path can operate directly on GPU-resident scalar fields."
+    ],
+    "options": [
+        "`'LevelList'` / `'Levels'` accepts an explicit, strictly increasing vector of contour values.",
+        "`'LevelStep'` specifies evenly spaced contour levels.",
+        "`'LineColor'` accepts MATLAB color strings, RGB triples, and contour-specific modes such as `'auto'` or `'none'` where supported."
+    ],
+    "examples": [
+        {
+            "description": "Create a contour line plot from a scalar field",
+            "input": "[X, Y] = meshgrid(-2:0.25:2, -2:0.25:2);\nZ = X .* exp(-X.^2 - Y.^2);\ncontour(X, Y, Z);"
+        },
+        {
+            "description": "Use explicit contour levels",
+            "input": "[X, Y] = meshgrid(-2:0.25:2, -2:0.25:2);\nZ = X .* exp(-X.^2 - Y.^2);\ncontour(X, Y, Z, [0 0.25 0.5]);"
+        },
+        {
+            "description": "Inspect the returned contour handle",
+            "input": "[X, Y] = meshgrid(1:20, 1:20);\nZ = X + Y;\nh = contour(X, Y, Z);\nget(h, 'Type')",
+            "output": "ans =\n    'contour'"
+        }
+    ],
+    "links": [
+        {
+            "label": "contourf",
+            "url": "./contourf"
+        },
+        {
+            "label": "surfc",
+            "url": "./surfc"
+        },
+        {
+            "label": "meshc",
+            "url": "./meshc"
+        },
+        {
+            "label": "colorbar",
+            "url": "./colorbar"
+        },
+        {
+            "label": "colormap",
+            "url": "./colormap"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/contour.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/contour.rs"
+    },
+    "key": "contour",
+    "slug": "contour",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=contour.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contour.js","sourceRoot":"","sources":["../../../src/generated/builtins/contour.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,eAAe;QACf,WAAW;QACX,YAAY;QACZ,gBAAgB;QAChB,mBAAmB;KACpB;IACD,SAAS,EAAE,sFAAsF;IACjG,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,8GAA8G;KACxH;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;KAC7C;IACD,aAAa,EAAE,sTAAsT;IACrU,WAAW,EAAE;QACX,0GAA0G;QAC1G,oFAAoF;QACpF,+FAA+F;QAC/F,oHAAoH;QACpH,wHAAwH;KACzH;IACD,SAAS,EAAE;QACT,+FAA+F;QAC/F,uDAAuD;QACvD,mIAAmI;KACpI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,0FAA0F;SACpG;QACD;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,wGAAwG;SAClH;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,mFAAmF;YAC5F,QAAQ,EAAE,sBAAsB;SACjC;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;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;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/contourf.d.ts

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

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

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

package/dist/generated/builtins/contourf.js

@@ -0,0 +1,90 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "contourf",
+    "category": "plotting",
+    "keywords": [
+        "contourf",
+        "filled contour plot",
+        "level regions",
+        "scalar field heatmap",
+        "matlab contourf"
+    ],
+    "summary": "Create filled contour plots for level regions, scalar fields, and MATLAB `contourf` workflows.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`contourf` uses the shared filled-contour pipeline and returns a contour-fill handle."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::contourf::tests"
+    },
+    "description": "`contourf` creates filled contour plots by coloring the regions between contour levels. In RunMat it returns a contour-fill handle, shares the contour level-generation path with `contour`, and acts as the filled-region counterpart to line-oriented contour plots.",
+    "behaviors": [
+        "`contourf(Z)` uses implicit axes, while `contourf(X, Y, Z)` accepts explicit coordinates.",
+        "The returned value is a contour-fill handle in the plotting object system.",
+        "Level-list, level-count, and related contour workflows mirror the broader contour family semantics.",
+        "`contourf` works naturally with `colorbar` and `colormap` because filled regions are fundamentally color-mapped scalar ranges.",
+        "Filled contours and optional line overlays are handled through the shared contour stack."
+    ],
+    "examples": [
+        {
+            "description": "Create a filled contour plot",
+            "input": "[X, Y] = meshgrid(-2:0.25:2, -2:0.25:2);\nZ = X .* exp(-X.^2 - Y.^2);\ncontourf(X, Y, Z);\ncolorbar;"
+        },
+        {
+            "description": "Use explicit levels with a colormap",
+            "input": "[X, Y] = meshgrid(-3:0.2:3, -3:0.2:3);\nZ = cos(X) .* sin(Y);\ncontourf(X, Y, Z, [-0.75 -0.25 0 0.25 0.75]);\ncolormap('turbo');"
+        },
+        {
+            "description": "Inspect the returned contour-fill handle",
+            "input": "[X, Y] = meshgrid(1:20, 1:20);\nZ = X - Y;\nh = contourf(X, Y, Z);\nget(h, 'Type')",
+            "output": "ans =\n    'contour'"
+        }
+    ],
+    "links": [
+        {
+            "label": "contour",
+            "url": "./contour"
+        },
+        {
+            "label": "colorbar",
+            "url": "./colorbar"
+        },
+        {
+            "label": "colormap",
+            "url": "./colormap"
+        },
+        {
+            "label": "surfc",
+            "url": "./surfc"
+        },
+        {
+            "label": "meshc",
+            "url": "./meshc"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/contourf.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/contourf.rs"
+    },
+    "key": "contourf",
+    "slug": "contourf",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=contourf.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contourf.js","sourceRoot":"","sources":["../../../src/generated/builtins/contourf.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,UAAU;QACV,qBAAqB;QACrB,eAAe;QACf,sBAAsB;QACtB,iBAAiB;KAClB;IACD,SAAS,EAAE,gGAAgG;IAC3G,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,uFAAuF;KACjG;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,qCAAqC;KAC9C;IACD,aAAa,EAAE,wQAAwQ;IACvR,WAAW,EAAE;QACX,2FAA2F;QAC3F,4EAA4E;QAC5E,qGAAqG;QACrG,gIAAgI;QAChI,0FAA0F;KAC3F;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,sGAAsG;SAChH;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,kIAAkI;SAC5I;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,oFAAoF;YAC7F,QAAQ,EAAE,sBAAsB;SACjC;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,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,4GAA4G;KACpH;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/conv.js

@@ -0,0 +1,177 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "conv",
+    "category": "math/signal",
+    "keywords": [
+        "conv",
+        "convolution",
+        "linear convolution",
+        "signal processing",
+        "polynomial multiplication",
+        "gpu"
+    ],
+    "summary": "One-dimensional linear convolution with MATLAB-compatible padding modes.",
+    "references": [
+        "title: \"MATLAB conv documentation\""
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "The in-process provider and WGPU backend expose conv1d; other providers fall back to the host implementation when this hook is unavailable."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::signal::conv::tests",
+        "integration": "builtins::math::signal::conv::tests::conv_gpu_roundtrip_matches_cpu"
+    },
+    "description": "`conv(a, b)` computes the one-dimensional linear convolution of the vectors `a` and `b`. The default padding mode returns the full convolution (`length(a) + length(b) - 1`). Optional shape arguments (`'same'`, `'valid'`) select MATLAB-compatible padding behaviour.",
+    "behaviors": [
+        "Accepts real or complex scalars, vectors, or tensors that can be flattened column-major into a vector.",
+        "Keeps the orientation of the first input when returning row or column vectors (`'same'` and `'valid'` honour this rule).",
+        "Supports the three MATLAB shape modes: `'full'` (default), `'same'`, and `'valid'`.",
+        "Returns empty outputs when either input is empty or when `'valid'` is requested with insufficient overlap.",
+        "Logical inputs are promoted to double precision before the convolution.",
+        "GPU inputs are gathered automatically when the active provider lacks a native 1-D convolution kernel."
+    ],
+    "examples": [
+        {
+            "description": "Computing the full convolution of two row vectors",
+            "input": "a = [1 2 3];\nb = [1 1 1];\nc = conv(a, b)",
+            "output": "c = [1 3 6 5 3]"
+        },
+        {
+            "description": "Keeping the same length as the first input",
+            "input": "kernel = [1 0 -1];\nsignal = [3 4 5 6 7];\nedge = conv(signal, kernel, 'same')",
+            "output": "edge = [4 2 2 2 -6]"
+        },
+        {
+            "description": "Valid convolution without zero padding",
+            "input": "weights = [1 2 3 4];\nwindow = [1 1 1];\nvalid = conv(weights, window, 'valid')",
+            "output": "valid = [6 9]"
+        },
+        {
+            "description": "Convolving column vectors",
+            "input": "a = (1:3)';\nb = [2; 0; -2];\nc = conv(a, b)",
+            "output": "c =\n     2\n     4\n     4\n     -4\n     -6"
+        },
+        {
+            "description": "Multiplying polynomials using convolution",
+            "input": "p = [1 3 3 1];    % (x + 1)^3 coefficients\nq = [1 -1];       % (x - 1)\ncoeff = conv(p, q)",
+            "output": "coeff = [1 2 0 -2 -1]"
+        },
+        {
+            "description": "Complex-valued convolution",
+            "input": "t = 0:3;\nsig = exp(1i * pi/4 * t);\nfilt = [1 2i];\nresp = conv(sig, filt)",
+            "output": "resp =\n   1.0000   0.7071 + 2.7071i  -1.4142 + 2.4142i  -2.7071 + 0.7071i  -1.4142 - 1.4142i"
+        },
+        {
+            "description": "Scaling a signal by a scalar",
+            "input": "s = [4 5 6];\ny = conv(2, s)",
+            "output": "y = [8 10 12]"
+        },
+        {
+            "description": "Using gpuArray inputs with automatic host fallback",
+            "input": "g = gpuArray([1 2 3 4]);\nh = gpuArray([1 0 -1]);\nedge = conv(g, h, 'same');\nresult = gather(edge)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `conv` require row vectors?",
+            "answer": "No. `conv` accepts row vectors, column vectors, scalars, and tensors that can be flattened into a vector. The result preserves the orientation of the first input when that orientation is unambiguous."
+        },
+        {
+            "question": "What happens when one of the inputs is empty?",
+            "answer": "The result is an empty vector with an orientation derived from the non-empty input (or a `0×1` column vector when both inputs are empty), matching MATLAB's behaviour."
+        },
+        {
+            "question": "How is `'same'` computed?",
+            "answer": "`'same'` returns the central portion of the full convolution whose length matches the first input. Internally RunMat performs a full convolution and slices the appropriate window."
+        },
+        {
+            "question": "When should I use `'valid'`?",
+            "answer": "Use `'valid'` when you only want results that do not rely on zero padding. This is common when sliding windows should fit completely inside the input without extending past the boundaries."
+        },
+        {
+            "question": "Does `conv` support single precision?",
+            "answer": "The host path computes in double precision. Provider implementations choose their native precision: the in-process provider mirrors double results, while the WGPU backend emits either `f32` or `f64` kernels depending on device support. Providers without a `conv1d` hook gather inputs back to the CPU to maintain MATLAB-compatible answers."
+        },
+        {
+            "question": "Will the result stay on the GPU?",
+            "answer": "Yes—provided the active provider exposes the `conv1d` hook (the in-process provider and WGPU backend do). Without that hook, RunMat gathers inputs, computes on the host, and returns a CPU tensor with the correct orientation."
+        },
+        {
+            "question": "Can I convolve matrices or higher-dimensional arrays?",
+            "answer": "`conv` treats inputs as vectors using MATLAB column-major order. For multi-dimensional convolution use the dedicated `conv2` or `convn` builtins (planned)."
+        },
+        {
+            "question": "How do I convolve with an impulse (delta) kernel?",
+            "answer": "Include a `1` followed by zeros in your kernel. The input will be preserved (with appropriate padding) because convolution with a delta function is an identity operation."
+        },
+        {
+            "question": "What about circular convolution?",
+            "answer": "Use `cconv` for circular convolution, or compute the FFT manually and multiply in the frequency domain before performing an inverse FFT."
+        },
+        {
+            "question": "Are there GPU-specific tuning knobs?",
+            "answer": "Not yet. Current providers choose kernel launch parameters automatically; user-facing tuning switches will arrive alongside future backend updates."
+        }
+    ],
+    "links": [
+        {
+            "label": "fft",
+            "url": "./fft"
+        },
+        {
+            "label": "ifft",
+            "url": "./ifft"
+        },
+        {
+            "label": "fftshift",
+            "url": "./fftshift"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "conv2",
+            "url": "./conv2"
+        },
+        {
+            "label": "deconv",
+            "url": "./deconv"
+        },
+        {
+            "label": "filter",
+            "url": "./filter"
+        }
+    ],
+    "source": {
+        "label": "Open a ticket",
+        "url": "https://github.com/runmat-org/runmat/issues/new/choose"
+    },
+    "key": "conv",
+    "slug": "conv",
+    "categoryPath": [
+        "math",
+        "signal"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=conv.js.map

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

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

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

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

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

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