runmat 0.4.9-dev.2 → 0.4.10-dev.0

package/dist/generated/builtins/repelem.js

@@ -0,0 +1,135 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "repelem",
+    "category": "array/shape",
+    "keywords": [
+        "repelem",
+        "replicate",
+        "repeat",
+        "array",
+        "cell"
+    ],
+    "summary": "Replicate each element of an array along one or more dimensions.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "GPU inputs are gathered to host memory before replication; no provider hook exists yet."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::shape::repelem::tests",
+        "integration": "crates/runmat-runtime/tests/nd_ops.rs"
+    },
+    "description": "`repelem(A, r1, r2, ..., rN)` repeats each element of `A` along the requested dimensions. Unlike `repmat`, which tiles whole arrays, `repelem` expands individual elements into runs or blocks.",
+    "behaviors": [
+        "`repelem(v, n)` repeats each element of a row or column vector `v` `n` times and preserves vector orientation.",
+        "`repelem(v, counts)` accepts a count vector with one non-negative integer count per element of `v`.",
+        "`repelem(A, r1, r2, ..., rN)` repeats matrix or N-D array elements along each dimension; scalar factors create element blocks and vector factors provide per-index counts for that dimension.",
+        "Numeric, logical, complex, string, char, and cell inputs are supported. Numeric, logical, complex, string, and cell arrays support N-D replication; char arrays are represented as 2-D character matrices.",
+        "Zero counts are allowed and remove the corresponding element or dimension slice from the output.",
+        "Replication counts must be finite, non-negative integers. Count vectors must match the size of the dimension they apply to.",
+        "The builtin checks shape and size overflow before materializing output arrays."
+    ],
+    "examples": [
+        {
+            "description": "Repeating every element of a row vector",
+            "input": "u = repelem([1 2 3], 2)",
+            "output": "u =\n     1     1     2     2     3     3"
+        },
+        {
+            "description": "Using a per-element count vector",
+            "input": "u = repelem([1 2 3], [1 2 3])",
+            "output": "u =\n     1     2     2     3     3     3"
+        },
+        {
+            "description": "Expanding a matrix into element blocks",
+            "input": "A = [1 2; 3 4];\nB = repelem(A, 2, 3)",
+            "output": "B =\n     1     1     1     2     2     2\n     1     1     1     2     2     2\n     3     3     3     4     4     4\n     3     3     3     4     4     4"
+        },
+        {
+            "description": "Dropping elements with zero counts",
+            "input": "u = repelem([1 2 3 4 5], [0 1 0 2 1])",
+            "output": "u =\n     2     4     4     5"
+        },
+        {
+            "description": "Repeating along a higher dimension",
+            "input": "C = {1; 2};\nD = repelem(reshape(C, [1 1 2]), 1, 1, 2);\nsize(D)",
+            "output": "ans =\n     1     1     4"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How is `repelem` different from `repmat`?",
+            "answer": "`repmat` tiles a whole array. `repelem` repeats each individual element, so matrix inputs expand into element-wise blocks."
+        },
+        {
+            "question": "Can counts be different for each element?",
+            "answer": "Yes. In vector form, the count vector must have one entry for each vector element. In multi-dimensional form, a count vector applies to the dimension at the same argument position."
+        },
+        {
+            "question": "Are zero counts valid?",
+            "answer": "Yes. A zero count omits that element or dimension index from the output."
+        },
+        {
+            "question": "Does `repelem` preserve row and column vector orientation?",
+            "answer": "Yes. Row vectors remain row vectors, column vectors remain column vectors, including empty column vectors."
+        },
+        {
+            "question": "Does `repelem` run on the GPU?",
+            "answer": "Not yet. The runtime gathers GPU tensors to host memory for this builtin, computes the replicated result on the CPU, and returns a host value."
+        }
+    ],
+    "links": [
+        {
+            "label": "repmat",
+            "url": "./repmat"
+        },
+        {
+            "label": "kron",
+            "url": "./kron"
+        },
+        {
+            "label": "reshape",
+            "url": "./reshape"
+        },
+        {
+            "label": "cat",
+            "url": "./cat"
+        },
+        {
+            "label": "size",
+            "url": "./size"
+        }
+    ],
+    "source": {
+        "label": "crates/runmat-runtime/src/builtins/array/shape/repelem.rs",
+        "url": "crates/runmat-runtime/src/builtins/array/shape/repelem.rs"
+    },
+    "gpu_residency": "`repelem` is currently a host-resident array construction builtin. If a GPU tensor reaches this builtin, RunMat gathers it before replication.",
+    "gpu_behavior": [
+        "RunMat does not yet expose a provider hook for element-wise replication. Backends can add one later without changing the MATLAB-facing behavior."
+    ],
+    "extended_capabilities": [
+        "`repelem` preserves the input value class for numeric dtype metadata, logical arrays, complex tensors, string arrays, char arrays, and cell arrays.",
+        "N-D numeric, logical, complex, string, and cell replication uses the runtime's native storage order for each value kind."
+    ],
+    "key": "repelem",
+    "slug": "repelem",
+    "aliases": [],
+    "categoryPath": [
+        "array",
+        "shape"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=repelem.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"repelem.js","sourceRoot":"","sources":["../../../src/generated/builtins/repelem.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,SAAS;QACT,WAAW;QACX,QAAQ;QACR,OAAO;QACP,MAAM;KACP;IACD,SAAS,EAAE,kEAAkE;IAC7E,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,yFAAyF;KACnG;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,wCAAwC;QAChD,aAAa,EAAE,uCAAuC;KACvD;IACD,aAAa,EAAE,iMAAiM;IAChN,WAAW,EAAE;QACX,gHAAgH;QAChH,qGAAqG;QACrG,+LAA+L;QAC/L,4MAA4M;QAC5M,kGAAkG;QAClG,6HAA6H;QAC7H,gFAAgF;KACjF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,yBAAyB;YAClC,QAAQ,EAAE,2CAA2C;SACtD;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,+BAA+B;YACxC,QAAQ,EAAE,2CAA2C;SACtD;QACD;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,uCAAuC;YAChD,QAAQ,EAAE,6JAA6J;SACxK;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,uCAAuC;YAChD,QAAQ,EAAE,+BAA+B;SAC1C;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,kEAAkE;YAC3E,QAAQ,EAAE,2BAA2B;SACtC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,4HAA4H;SACvI;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,sLAAsL;SACjM;QACD;YACE,UAAU,EAAE,wBAAwB;YACpC,QAAQ,EAAE,0EAA0E;SACrF;QACD;YACE,UAAU,EAAE,4DAA4D;YACxE,QAAQ,EAAE,4GAA4G;SACvH;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,gJAAgJ;SAC3J;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,2DAA2D;KACnE;IACD,eAAe,EAAE,gJAAgJ;IACjK,cAAc,EAAE;QACd,kJAAkJ;KACnJ;IACD,uBAAuB,EAAE;QACvB,qJAAqJ;QACrJ,0HAA0H;KAC3H;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/sawtooth.js

@@ -0,0 +1,111 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "sawtooth",
+    "category": "math/signal",
+    "keywords": [
+        "sawtooth",
+        "waveform",
+        "signal processing",
+        "triangle",
+        "periodic",
+        "elementwise"
+    ],
+    "summary": "Generate a periodic sawtooth waveform with optional peak position.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f64"
+        ],
+        "broadcasting": "elementwise",
+        "notes": "GPU inputs are gathered to the host so the reference implementation can guarantee MATLAB-compatible piecewise-linear evaluation at the period boundary."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline",
+        "notes": "Fusion is intentionally disabled for v1 because the WGSL piecewise expression is non-trivial and brings little benefit relative to the host loop."
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::signal::sawtooth::tests",
+        "integration": null
+    },
+    "description": "`y = sawtooth(t)` generates a sawtooth wave with period `2*pi` at the sample times in `t`, ranging in `[-1, 1]`. `y = sawtooth(t, xmax)` controls the peak position with `xmax` in `[0, 1]`: `xmax = 1` (the default) produces a rising sawtooth, `xmax = 0` produces a falling sawtooth, and intermediate values such as `xmax = 0.5` produce a triangle wave whose peak is at the centre of each period.",
+    "behaviors": [
+        "Operates element-wise on scalars, vectors, matrices, and N-D tensors; preserves input shape.",
+        "Reduces input modulo `2*pi` so the waveform is periodic across negative and positive sample times.",
+        "Returns `-1` at the start of each period and approaches `+1` just before the period boundary wraps when `xmax = 1`.",
+        "Returns a piecewise-linear triangle wave when `xmax = 0.5`, peaking at `1` at the centre of each period.",
+        "Returns a pure falling ramp when `xmax = 0` and a pure rising ramp when `xmax = 1`.",
+        "Integer and logical inputs are promoted to double precision before evaluation.",
+        "Non-finite sample times (`NaN`, `+Inf`, `-Inf`) propagate as `NaN` element-wise, matching MATLAB.",
+        "Complex and text inputs are rejected with a builtin-scoped error.",
+        "Rejects `xmax` values outside `[0, 1]` and non-scalar `xmax` arguments."
+    ],
+    "examples": [
+        {
+            "description": "Default rising sawtooth over two periods",
+            "input": "t = 0:pi/2:4*pi;\ny = sawtooth(t)",
+            "output": "y = [-1 -0.5 0 0.5 -1 -0.5 0 0.5 -1]"
+        },
+        {
+            "description": "Triangle wave via xmax = 0.5",
+            "input": "t = linspace(0, 2*pi, 5);\ny = sawtooth(t, 0.5)",
+            "output": "y = [-1 0 1 0 -1]"
+        },
+        {
+            "description": "Pure falling sawtooth via xmax = 0",
+            "input": "y = sawtooth([0 pi 2*pi], 0)",
+            "output": "y = [1 0 1]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why does `sawtooth(2*pi)` return `-1` instead of `+1`?",
+            "answer": "RunMat reduces the input modulo `2*pi`, so `2*pi` is folded back to the start of the next period. The default rising sawtooth therefore restarts at `-1` exactly on each period boundary, matching MATLAB."
+        },
+        {
+            "question": "How do I produce a triangle wave?",
+            "answer": "Pass `xmax = 0.5` so the peak sits at the centre of each period and the waveform ramps symmetrically up and back down."
+        },
+        {
+            "question": "Can `sawtooth` accept complex inputs?",
+            "answer": "No. `sawtooth` is defined on real samples and rejects complex inputs with a builtin-scoped error to match MATLAB."
+        }
+    ],
+    "links": [
+        {
+            "label": "square",
+            "url": "./square"
+        },
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "cos",
+            "url": "./cos"
+        },
+        {
+            "label": "linspace",
+            "url": "./linspace"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/signal/sawtooth.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/signal/sawtooth.rs"
+    },
+    "key": "sawtooth",
+    "slug": "sawtooth",
+    "aliases": [],
+    "categoryPath": [
+        "math",
+        "signal"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=sawtooth.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sawtooth.js","sourceRoot":"","sources":["../../../src/generated/builtins/sawtooth.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,UAAU;QACV,UAAU;QACV,mBAAmB;QACnB,UAAU;QACV,UAAU;QACV,aAAa;KACd;IACD,SAAS,EAAE,oEAAoE;IAC/E,YAAY,EAAE,EAAE;IAChB,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,aAAa;QAC7B,OAAO,EAAE,yJAAyJ;KACnK;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;QACrB,OAAO,EAAE,mJAAmJ;KAC7J;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,yCAAyC;QACjD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,4YAA4Y;IAC3Z,WAAW,EAAE;QACX,8FAA8F;QAC9F,oGAAoG;QACpG,qHAAqH;QACrH,0GAA0G;QAC1G,qFAAqF;QACrF,gFAAgF;QAChF,mGAAmG;QACnG,mEAAmE;QACnE,yEAAyE;KAC1E;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,mCAAmC;YAC5C,QAAQ,EAAE,sCAAsC;SACjD;QACD;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,iDAAiD;YAC1D,QAAQ,EAAE,mBAAmB;SAC9B;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,8BAA8B;YACvC,QAAQ,EAAE,aAAa;SACxB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,wDAAwD;YACpE,QAAQ,EAAE,4MAA4M;SACvN;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,wHAAwH;SACnI;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,mHAAmH;SAC9H;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;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,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/sinc.js

@@ -0,0 +1,142 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "sinc",
+    "category": "math/signal",
+    "keywords": [
+        "sinc",
+        "normalized sinc",
+        "signal processing",
+        "elementwise",
+        "complex"
+    ],
+    "summary": "Normalized sinc, sin(pi*x)/(pi*x), evaluated element-wise.",
+    "references": [
+        "title: \"MATLAB sinc documentation\""
+    ],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Providers may execute sinc on-device through unary_sinc. The runtime gathers to the host only when a provider lacks that hook or cannot service the input."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::signal::sinc::tests",
+        "integration": "builtins::math::signal::sinc::tests::sinc_gpu_input_stays_resident_when_provider_supports_sinc"
+    },
+    "description": "`y = sinc(x)` evaluates the normalized sinc function element-wise using MATLAB's definition `sin(pi*x)/(pi*x)`, with `sinc(0)` defined as `1`.",
+    "behaviors": [
+        "Accepts real or complex scalars, vectors, matrices, and N-D tensors.",
+        "Preserves the input shape for vector, matrix, and N-D tensor inputs.",
+        "Returns `1` for exactly zero real inputs.",
+        "Returns exact `0` for finite nonzero integer-valued real inputs, matching MATLAB's `sinpi`-style integer accuracy where practical.",
+        "Logical and integer inputs are promoted to double precision before evaluation.",
+        "Complex inputs use the analytic extension `sin(pi*z)/(pi*z)` and return `1 + 0i` for `z == 0`.",
+        "GPU inputs stay resident when the active provider supports `unary_sinc`; otherwise RunMat gathers automatically and evaluates with the host implementation."
+    ],
+    "examples": [
+        {
+            "description": "Evaluate sinc at zero",
+            "input": "y = sinc(0)",
+            "output": "y = 1"
+        },
+        {
+            "description": "Evaluate sinc at integer inputs",
+            "input": "x = 1:5;\ny = sinc(x)",
+            "output": "y = [0 0 0 0 0]"
+        },
+        {
+            "description": "Evaluate normalized sinc values",
+            "input": "x = [-1 0 1 0.5];\ny = sinc(x)",
+            "output": "y = [0 1 0 0.6366]"
+        },
+        {
+            "description": "Preserve matrix shape",
+            "input": "A = [0 0.5; 1.5 2];\nY = sinc(A)",
+            "output": "Y =\n    1.0000    0.6366\n   -0.2122         0"
+        },
+        {
+            "description": "Evaluate sinc for a complex value",
+            "input": "z = sinc(0.5 + 0.25i)"
+        },
+        {
+            "description": "Use gpuArray input",
+            "input": "g = gpuArray([0 0.5 1]);\ny = sinc(g);\nresult = gather(y)",
+            "output": "result = [1 0.6366 0]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Which sinc definition does RunMat use?",
+            "answer": "RunMat uses MATLAB's normalized definition, `sin(pi*x)/(pi*x)`, with the removable singularity at zero defined as `1`."
+        },
+        {
+            "question": "Why does `sinc(1:5)` return exact zeros?",
+            "answer": "The implementation detects finite nonzero integer-valued real inputs before evaluating the trigonometric expression. This avoids floating-point residuals from `sin(pi*x)` and matches MATLAB's practical `sinpi` behaviour."
+        },
+        {
+            "question": "Does `sinc` support complex values?",
+            "answer": "Yes. Complex scalars and complex tensors use the analytic extension `sin(pi*z)/(pi*z)` and preserve tensor shape."
+        },
+        {
+            "question": "Will `sinc(gpuArray(...))` stay on the GPU?",
+            "answer": "Yes when the active provider implements `unary_sinc`. Providers without that hook fall back to host evaluation so zero and integer cases still use the exact MATLAB-compatible path."
+        }
+    ],
+    "links": [
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "fft",
+            "url": "./fft"
+        },
+        {
+            "label": "filter",
+            "url": "./filter"
+        },
+        {
+            "label": "conv",
+            "url": "./conv"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/signal/sinc.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/signal/sinc.rs"
+    },
+    "gpu_residency": "`sinc` keeps real GPU tensors resident when the active provider exposes `unary_sinc`. The runtime preserves a host fallback for providers that do not support the hook.",
+    "gpu_behavior": [
+        "Provider-backed execution uses the same normalized sinc semantics, including `sinc(0) == 1` and exact zeros for finite nonzero integer-valued real inputs.",
+        "If the provider declines the operation, RunMat gathers through the active provider and evaluates with the host implementation.",
+        "Fusion emits a guarded normalized sinc expression with explicit zero and integer branches for real elementwise graphs."
+    ],
+    "key": "sinc",
+    "slug": "sinc",
+    "aliases": [],
+    "categoryPath": [
+        "math",
+        "signal"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=sinc.js.map

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

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

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

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

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

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

package/dist/generated/builtins/sind.js

@@ -0,0 +1,109 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "sind",
+    "category": "math/trigonometry",
+    "keywords": [
+        "sind",
+        "sine",
+        "degrees",
+        "angle",
+        "trigonometry",
+        "elementwise"
+    ],
+    "summary": "Sine of angles expressed in degrees with MATLAB-exact values at canonical multiples.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f64"
+        ],
+        "broadcasting": "elementwise",
+        "notes": "GPU inputs are gathered to the host so the reference implementation can guarantee MATLAB-exact values at canonical multiples of 30, 90, 150, and 180 degrees."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline",
+        "notes": "Fusion is intentionally disabled for v1 because the WGSL `sin(x*pi/180)` form would lose MATLAB's exact-value guarantees at canonical angles."
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::trigonometry::sind::tests",
+        "integration": null
+    },
+    "description": "`y = sind(x)` evaluates the sine of each angle in `x`, interpreting the values in degrees rather than radians. The implementation reduces the angle modulo 360 and special-cases 0, 30, 90, 150, and 180 (and their negative/wrapped counterparts) so the result matches MATLAB's exact 0, ±0.5, and ±1 values without floating-point noise.",
+    "behaviors": [
+        "Operates element-wise on scalars, vectors, matrices, and N-D tensors.",
+        "Integer and logical inputs are promoted to double precision before evaluation.",
+        "Returns exactly 0 at multiples of 180 and exactly ±1 at the odd multiples of 90 (±90 + 360k).",
+        "Returns exactly ±0.5 at angles congruent to ±30 or ±150 modulo 360.",
+        "Complex inputs delegate to the analytic extension of `sin` after scaling by `pi/180`; exact-value treatment for complex operands is deferred.",
+        "Output shape matches the input shape; non-finite inputs propagate as `NaN`.",
+        "String inputs are unsupported and raise a builtin-scoped error."
+    ],
+    "examples": [
+        {
+            "description": "Sine of a canonical degree angle",
+            "input": "y = sind(30)",
+            "output": "y = 0.5"
+        },
+        {
+            "description": "Sine of multiples of 180 returns exactly zero",
+            "input": "y = sind([0 180 360])",
+            "output": "y = [0 0 0]"
+        },
+        {
+            "description": "Sine of a vector of common angles",
+            "input": "angles = [0 30 45 60 90];\ny = sind(angles)",
+            "output": "y = [0 0.5 0.7071 0.8660 1]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why does `sind(180)` return exactly zero?",
+            "answer": "MATLAB guarantees an exact zero at multiples of 180 to avoid floating-point noise from `pi`. RunMat reduces the angle modulo 360 and short-circuits the canonical cases before delegating to `sin`."
+        },
+        {
+            "question": "Is `sind(x)` equivalent to `sin(x*pi/180)`?",
+            "answer": "Mathematically yes, but the floating-point result differs at canonical angles because `pi/180` is not exact in binary floating point. `sind` returns the exact MATLAB values at multiples of 30, 90, 150, and 180."
+        },
+        {
+            "question": "Does `sind` support arrays?",
+            "answer": "Yes. Scalars, vectors, matrices, and N-D tensors are all handled element-wise; the shape of the input is preserved."
+        }
+    ],
+    "links": [
+        {
+            "label": "cosd",
+            "url": "./cosd"
+        },
+        {
+            "label": "tand",
+            "url": "./tand"
+        },
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "deg2rad",
+            "url": "./deg2rad"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/trigonometry/sind.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/trigonometry/sind.rs"
+    },
+    "key": "sind",
+    "slug": "sind",
+    "aliases": [],
+    "categoryPath": [
+        "math",
+        "trigonometry"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=sind.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sind.js","sourceRoot":"","sources":["../../../src/generated/builtins/sind.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,MAAM;QACN,MAAM;QACN,SAAS;QACT,OAAO;QACP,cAAc;QACd,aAAa;KACd;IACD,SAAS,EAAE,sFAAsF;IACjG,YAAY,EAAE,EAAE;IAChB,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,aAAa;QAC7B,OAAO,EAAE,+JAA+J;KACzK;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;QACrB,OAAO,EAAE,+IAA+I;KACzJ;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,2CAA2C;QACnD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,8UAA8U;IAC7V,WAAW,EAAE;QACX,uEAAuE;QACvE,gFAAgF;QAChF,+FAA+F;QAC/F,qEAAqE;QACrE,+IAA+I;QAC/I,6EAA6E;QAC7E,iEAAiE;KAClE;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,cAAc;YACvB,QAAQ,EAAE,SAAS;SACpB;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,uBAAuB;YAChC,QAAQ,EAAE,aAAa;SACxB;QACD;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,6CAA6C;YACtD,QAAQ,EAAE,6BAA6B;SACxC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,qMAAqM;SAChN;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,oNAAoN;SAC/N;QACD;YACE,UAAU,EAAE,6BAA6B;YACzC,QAAQ,EAAE,qHAAqH;SAChI;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,gEAAgE;QACzE,KAAK,EAAE,6GAA6G;KACrH;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,cAAc;KACf;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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