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

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

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

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

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

package/dist/generated/builtins/complex.js

@@ -0,0 +1,157 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "complex",
+    "category": "math/elementwise",
+    "keywords": [
+        "complex",
+        "complex constructor",
+        "real part",
+        "imaginary part",
+        "complex storage",
+        "MATLAB complex"
+    ],
+    "summary": "Construct complex double values from real and imaginary parts.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/complex.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "scalar-only",
+        "notes": "Complex tensors are currently host-resident in RunMat. GPU tensor inputs are not accepted by this constructor until native complex GPU buffers are wired through the runtime."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::elementwise::complex::tests"
+    },
+    "description": "`z = complex(a, b)` constructs `a + 1i*b` from real-valued inputs. `z = complex(a)` returns `a` using complex storage with a zero imaginary part, and existing complex inputs pass through unchanged.",
+    "behaviors": [
+        "With two inputs, `a` and `b` must be real numeric values. Complex inputs raise an error.",
+        "Two non-scalar inputs must have the same size. If either input is scalar, it expands across the other input.",
+        "Integer and logical inputs are promoted to double precision before constructing the complex result.",
+        "String and character inputs are rejected because the constructor accepts numeric inputs only.",
+        "Unary `complex(a)` preserves existing complex scalars and complex tensors. Real inputs become complex values with zero imaginary parts.",
+        "Empty real tensors preserve their empty shape and return empty complex tensors."
+    ],
+    "examples": [
+        {
+            "description": "Constructing a complex scalar from real and imaginary parts",
+            "input": "z = complex(3, 4)",
+            "output": "z = 3+4i"
+        },
+        {
+            "description": "Constructing a complex row vector from matching real arrays",
+            "input": "re = [1 2 3];\nim = [4 5 6];\nz = complex(re, im)",
+            "output": "z = [1+4i 2+5i 3+6i]"
+        },
+        {
+            "description": "Expanding a scalar imaginary part across an array",
+            "input": "re = [1 2 3];\nz = complex(re, -1)",
+            "output": "z = [1-1i 2-1i 3-1i]"
+        },
+        {
+            "description": "Forcing complex storage with a zero imaginary part",
+            "input": "z = complex(12);\ntf = isreal(z)",
+            "output": "z = 12+0i\n\ntf =\n     0"
+        },
+        {
+            "description": "Leaving an existing complex value unchanged",
+            "input": "z = complex(1 + 2i)",
+            "output": "z = 1+2i"
+        },
+        {
+            "description": "Rejecting non-scalar implicit expansion",
+            "input": "z = complex([1 2 3], [10; 20])",
+            "output": "error: complex: real and imaginary parts must have the same size, unless one input is scalar"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `complex(a, b)` use MATLAB implicit expansion?",
+            "answer": "Only scalar expansion is supported for this constructor. Two non-scalar operands must have identical sizes, matching MATLAB's documented `complex` size rules."
+        },
+        {
+            "question": "Can I pass complex values to `complex(a, b)`?",
+            "answer": "No. The two-argument constructor requires real numeric inputs for both the real and imaginary parts. Use `real`, `imag`, or arithmetic if you need to transform existing complex values."
+        },
+        {
+            "question": "What does unary `complex(a)` do?",
+            "answer": "It forces real input into complex storage with a zero imaginary part. If `a` is already complex, RunMat returns it unchanged."
+        },
+        {
+            "question": "Why does `isreal(complex(5))` return false?",
+            "answer": "`complex(5)` stores the value as complex double data with an explicit zero imaginary part. MATLAB and RunMat define `isreal` by storage, so it returns `false`."
+        },
+        {
+            "question": "Does `complex` accept logical inputs?",
+            "answer": "Yes. RunMat promotes logical values to doubles (`true` becomes `1`, `false` becomes `0`) before constructing the complex output."
+        },
+        {
+            "question": "Does `complex` accept strings or character arrays?",
+            "answer": "No. Strings and character arrays are rejected because the constructor is limited to numeric inputs."
+        },
+        {
+            "question": "Can `complex` run on GPU arrays?",
+            "answer": "Not yet. RunMat's complex tensor representation is currently host-resident, so this builtin does not accept `gpuArray` inputs."
+        }
+    ],
+    "links": [
+        {
+            "label": "real",
+            "url": "./real"
+        },
+        {
+            "label": "imag",
+            "url": "./imag"
+        },
+        {
+            "label": "isreal",
+            "url": "./isreal"
+        },
+        {
+            "label": "conj",
+            "url": "./conj"
+        },
+        {
+            "label": "angle",
+            "url": "./angle"
+        },
+        {
+            "label": "abs",
+            "url": "./abs"
+        },
+        {
+            "label": "double",
+            "url": "./double"
+        },
+        {
+            "label": "single",
+            "url": "./single"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/elementwise/complex.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/complex.rs"
+    },
+    "gpu_residency": "No. `complex` returns host-resident `Value::Complex` or `Value::ComplexTensor` values today. Use `gather` before construction if values are currently device-resident.",
+    "gpu_behavior": [
+        "RunMat rejects `gpuArray` inputs for `complex` today because the active GPU providers expose real-valued tensor buffers, while this constructor creates complex storage. Native complex GPU residency can be added later without changing the public call forms."
+    ],
+    "key": "complex",
+    "slug": "complex",
+    "aliases": [],
+    "categoryPath": [
+        "math",
+        "elementwise"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=complex.js.map

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

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

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

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

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

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

@@ -0,0 +1,109 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "cosd",
+    "category": "math/trigonometry",
+    "keywords": [
+        "cosd",
+        "cosine",
+        "degrees",
+        "angle",
+        "trigonometry",
+        "elementwise"
+    ],
+    "summary": "Cosine 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 60, 90, 120, and 180 degrees."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline",
+        "notes": "Fusion is intentionally disabled for v1 because the WGSL `cos(x*pi/180)` form would lose MATLAB's exact-value guarantees at canonical angles."
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::trigonometry::cosd::tests",
+        "integration": null
+    },
+    "description": "`y = cosd(x)` evaluates the cosine of each angle in `x`, interpreting the values in degrees rather than radians. The implementation reduces the angle modulo 360 and special-cases 0, 60, 90, 120, 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 90 and exactly ±1 at multiples of 180.",
+        "Returns exactly ±0.5 at multiples of 60 and 120.",
+        "Complex inputs delegate to the analytic extension of `cos` 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": "Cosine of a canonical degree angle",
+            "input": "y = cosd(60)",
+            "output": "y = 0.5"
+        },
+        {
+            "description": "Cosine of multiples of 90 returns exactly zero",
+            "input": "y = cosd([90 270])",
+            "output": "y = [0 0]"
+        },
+        {
+            "description": "Cosine of a vector of common angles",
+            "input": "angles = [0 30 45 60 90];\ny = cosd(angles)",
+            "output": "y = [1 0.8660 0.7071 0.5 0]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why does `cosd(90)` return exactly zero?",
+            "answer": "MATLAB guarantees an exact zero at multiples of 90 to avoid floating-point noise from `pi`. RunMat reduces the angle modulo 360 and short-circuits the canonical cases before delegating to `cos`."
+        },
+        {
+            "question": "Is `cosd(x)` equivalent to `cos(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. `cosd` returns the exact MATLAB values at multiples of 60, 90, 120, and 180."
+        },
+        {
+            "question": "Does `cosd` 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": "sind",
+            "url": "./sind"
+        },
+        {
+            "label": "tand",
+            "url": "./tand"
+        },
+        {
+            "label": "cos",
+            "url": "./cos"
+        },
+        {
+            "label": "deg2rad",
+            "url": "./deg2rad"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/trigonometry/cosd.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/trigonometry/cosd.rs"
+    },
+    "key": "cosd",
+    "slug": "cosd",
+    "aliases": [],
+    "categoryPath": [
+        "math",
+        "trigonometry"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=cosd.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cosd.js","sourceRoot":"","sources":["../../../src/generated/builtins/cosd.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,QAAQ;QACR,SAAS;QACT,OAAO;QACP,cAAc;QACd,aAAa;KACd;IACD,SAAS,EAAE,wFAAwF;IACnG,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,gVAAgV;IAC/V,WAAW,EAAE;QACX,uEAAuE;QACvE,gFAAgF;QAChF,0EAA0E;QAC1E,kDAAkD;QAClD,+IAA+I;QAC/I,6EAA6E;QAC7E,iEAAiE;KAClE;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,cAAc;YACvB,QAAQ,EAAE,SAAS;SACpB;QACD;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,oBAAoB;YAC7B,QAAQ,EAAE,WAAW;SACtB;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,6CAA6C;YACtD,QAAQ,EAAE,6BAA6B;SACxC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,oMAAoM;SAC/M;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/db.d.ts

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

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

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

package/dist/generated/builtins/db.js

@@ -0,0 +1,122 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "db",
+    "category": "control",
+    "keywords": [
+        "db",
+        "decibel",
+        "voltage",
+        "power",
+        "resistance",
+        "complex"
+    ],
+    "summary": "Convert numeric values to decibels using MATLAB-compatible voltage, power, or resistance forms.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "matlab",
+        "notes": "gpuArray inputs are gathered to the host before conversion. No provider-level GPU kernel is required for this compound builtin."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline",
+        "notes": "`db` parses optional string modes and resistance values, so it executes as a host-side fusion boundary."
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::control::db::tests"
+    },
+    "description": "`Y = db(X)` converts magnitudes to decibels with `20*log10(abs(X))`. `db(X, 'power')` uses `10*log10(abs(X))`, and `db(X, R)` treats `X` as voltage across resistance `R` and returns `10*log10(abs(X).^2 ./ R)`.",
+    "behaviors": [
+        "`db(X)` and `db(X, 'voltage')` compute voltage-style decibels with `20*log10(abs(X))`.",
+        "`db(X, 'power')` computes power-style decibels with `10*log10(abs(X))`.",
+        "`db(X, R)` computes power through a finite positive resistance with `10*log10(abs(X).^2 ./ R)`.",
+        "Complex inputs are converted through their magnitude before applying the decibel formula.",
+        "The resistance form supports MATLAB implicit expansion between `X` and `R`.",
+        "Zero input returns `-Inf`, matching the logarithm singularity at zero.",
+        "Integer and logical inputs are promoted to double precision."
+    ],
+    "examples": [
+        {
+            "description": "Voltage-style decibel conversion",
+            "input": "y = db(10)",
+            "output": "y = 20"
+        },
+        {
+            "description": "Power-style decibel conversion",
+            "input": "p = db(100, 'power')",
+            "output": "p = 20"
+        },
+        {
+            "description": "Voltage across a reference resistance",
+            "input": "p = db(10, 50)",
+            "output": "p = 3.0103"
+        },
+        {
+            "description": "Complex magnitude conversion",
+            "input": "z = db(3 + 4i)",
+            "output": "z = 13.9794"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What is the default mode?",
+            "answer": "The default is voltage mode, equivalent to `db(X, 'voltage')`."
+        },
+        {
+            "question": "How does `db` handle complex values?",
+            "answer": "RunMat first computes `abs(X)` and then applies the selected decibel formula, so complex outputs are not produced."
+        },
+        {
+            "question": "What happens for zero input?",
+            "answer": "`db(0)` returns `-Inf` because `log10(0)` is negative infinity."
+        },
+        {
+            "question": "Can resistance be an array?",
+            "answer": "Yes. The resistance form broadcasts `X` and `R` using MATLAB implicit expansion. Resistance values must be finite and positive."
+        }
+    ],
+    "links": [
+        {
+            "label": "abs",
+            "url": "./abs"
+        },
+        {
+            "label": "log10",
+            "url": "./log10"
+        },
+        {
+            "label": "tf",
+            "url": "./tf"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/control/db.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/control/db.rs"
+    },
+    "syntax": {
+        "example": {
+            "description": "Supported forms",
+            "input": "Y = db(X)\nY = db(X, 'voltage')\nY = db(X, 'power')\nY = db(X, R)",
+            "output": "Y is a real double scalar or array."
+        },
+        "points": [
+            "`X` may be real or complex numeric data.",
+            "`R` is a finite positive real numeric scalar or array.",
+            "The output shape follows `X` for mode arguments and the broadcasted shape of `X` and `R` for the resistance form."
+        ]
+    },
+    "key": "db",
+    "slug": "db",
+    "aliases": [],
+    "categoryPath": [
+        "control"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=db.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"db.js","sourceRoot":"","sources":["../../../src/generated/builtins/db.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,IAAI;IACb,UAAU,EAAE,SAAS;IACrB,UAAU,EAAE;QACV,IAAI;QACJ,SAAS;QACT,SAAS;QACT,OAAO;QACP,YAAY;QACZ,SAAS;KACV;IACD,SAAS,EAAE,iGAAiG;IAC5G,YAAY,EAAE,EAAE;IAChB,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,iIAAiI;KAC3I;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;QACrB,OAAO,EAAE,yGAAyG;KACnH;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,8BAA8B;KACvC;IACD,aAAa,EAAE,mNAAmN;IAClO,WAAW,EAAE;QACX,wFAAwF;QACxF,yEAAyE;QACzE,iGAAiG;QACjG,2FAA2F;QAC3F,6EAA6E;QAC7E,wEAAwE;QACxE,8DAA8D;KAC/D;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,YAAY;YACrB,QAAQ,EAAE,QAAQ;SACnB;QACD;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,sBAAsB;YAC/B,QAAQ,EAAE,QAAQ;SACnB;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,gBAAgB;YACzB,QAAQ,EAAE,YAAY;SACvB;QACD;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,gBAAgB;YACzB,QAAQ,EAAE,aAAa;SACxB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2BAA2B;YACvC,QAAQ,EAAE,gEAAgE;SAC3E;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,oHAAoH;SAC/H;QACD;YACE,UAAU,EAAE,8BAA8B;YAC1C,QAAQ,EAAE,iEAAiE;SAC5E;QACD;YACE,UAAU,EAAE,6BAA6B;YACzC,QAAQ,EAAE,iIAAiI;SAC5I;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,IAAI;YACb,KAAK,EAAE,MAAM;SACd;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,oDAAoD;QAC7D,KAAK,EAAE,iGAAiG;KACzG;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,iBAAiB;YAChC,OAAO,EAAE,mEAAmE;YAC5E,QAAQ,EAAE,qCAAqC;SAChD;QACD,QAAQ,EAAE;YACR,0CAA0C;YAC1C,wDAAwD;YACxD,mHAAmH;SACpH;KACF;IACD,KAAK,EAAE,IAAI;IACX,MAAM,EAAE,IAAI;IACZ,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/fill3.js

@@ -0,0 +1,152 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "fill3",
+    "category": "plotting",
+    "keywords": [
+        "fill3",
+        "3-D filled polygon",
+        "patch",
+        "polygon",
+        "matlab fill3",
+        "3d patch"
+    ],
+    "summary": "Create MATLAB-compatible filled polygon patches in 3-D space.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`fill3` is a plotting sink. It lowers coordinate and color argument groups to `patch` objects, gathering GPU-resident coordinate inputs through the shared patch path."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 4,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::fill3::tests"
+    },
+    "description": "`fill3` creates filled polygon graphics objects from X, Y, and Z coordinate data. RunMat implements it as a thin wrapper over the shared `patch` machinery, so returned handles are patch graphics handles and common patch name-value properties apply.",
+    "behaviors": [
+        "`fill3(X, Y, Z, C)` creates one or more 3-D filled polygons from matching coordinate arrays.",
+        "Vector coordinate inputs create one polygon.",
+        "Matrix coordinate inputs create one polygon per column through the underlying `patch` parser.",
+        "Multiple `X,Y,Z,C` groups in one call create multiple patch objects and return a row vector of patch handles.",
+        "A single polygon group returns a scalar patch handle.",
+        "`fill3` initializes the target axes with the standard 3-D view, so even polygons in the z=0 plane render as 3-D patch content.",
+        "Trailing patch property name-value pairs are applied to every polygon group in the call.",
+        "The returned patch handles work with `get`, `set`, `ishandle`, and `isgraphics`.",
+        "Color strings and RGB triples are supported through the shared patch color parser.",
+        "Indexed or interpolated CData behavior is currently limited by the underlying `patch` implementation; concrete color strings, RGB triples, and common patch properties are the supported color path."
+    ],
+    "options": [
+        "`FaceColor` accepts color names, RGB triples, `flat`, or `none` through `patch`.",
+        "`EdgeColor` accepts color names, RGB triples, or `none`.",
+        "`FaceAlpha` and `EdgeAlpha` accept numeric values from 0 to 1.",
+        "`LineWidth`, `DisplayName`, and `Visible` use the shared plotting property model.",
+        "Explicit axes handles are accepted as the leading argument, matching other RunMat plotting builtins."
+    ],
+    "examples": [
+        {
+            "description": "Create a red square in the z=0 plane",
+            "input": "x = [0 1 1 0];\ny = [0 0 1 1];\nz = [0 0 0 0];\nh = fill3(x, y, z, 'r');\nget(h, 'Type')",
+            "output": "ans =\n    'patch'"
+        },
+        {
+            "description": "Create two filled polygons in one call",
+            "input": "x1 = [0 1 0];\ny1 = [0 0 1];\nz1 = [0 0 0];\nx2 = [2 3 3 2];\ny2 = [0 0 1 1];\nz2 = [1 1 1 1];\nh = fill3(x1, y1, z1, 'g', x2, y2, z2, [0 0 1]);"
+        },
+        {
+            "description": "Apply patch properties to a fill3 polygon",
+            "input": "x = [0 1 0];\ny = [0 0 1];\nz = [0.25 0.5 0.75];\nh = fill3(x, y, z, [0.25 0.5 0.75], 'EdgeColor', 'none', 'FaceAlpha', 0.5);"
+        },
+        {
+            "description": "Create one patch per matrix column",
+            "input": "X = [0 2; 1 3; 1 3; 0 2];\nY = [0 0; 0 0; 1 1; 1 1];\nZ = [0 1; 0 1; 0 1; 0 1];\nfill3(X, Y, Z, 'cyan');\nview(3);"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What does fill3 return?",
+            "answer": "`fill3` returns patch graphics handles. A single polygon group returns one scalar handle; multiple groups return a row vector of handles."
+        },
+        {
+            "question": "How is fill3 related to patch?",
+            "answer": "`fill3` lowers its positional `X,Y,Z,C` inputs into the same `patch` object machinery. This keeps geometry validation, color parsing, property handling, rendering, and handle behavior consistent with `patch`."
+        },
+        {
+            "question": "Can I pass patch properties to fill3?",
+            "answer": "Yes. Trailing name-value pairs such as `'EdgeColor', 'none'`, `'FaceAlpha', 0.5`, and `'LineWidth', 2` are forwarded to the patch objects created by `fill3`."
+        },
+        {
+            "question": "Does fill3 support GPU-resident inputs?",
+            "answer": "GPU-resident coordinate inputs are gathered through the shared patch path for validation and polygon construction, then the resulting geometry is rendered through RunMat's GPU plotting renderer."
+        },
+        {
+            "question": "Does fill3 support indexed CData?",
+            "answer": "The current implementation is constrained by `patch`: color strings and RGB triples are supported, while full MATLAB indexed/interpolated CData behavior is deferred."
+        }
+    ],
+    "links": [
+        {
+            "label": "patch",
+            "url": "./patch"
+        },
+        {
+            "label": "plot3",
+            "url": "./plot3"
+        },
+        {
+            "label": "scatter3",
+            "url": "./scatter3"
+        },
+        {
+            "label": "surf",
+            "url": "./surf"
+        },
+        {
+            "label": "view",
+            "url": "./view"
+        },
+        {
+            "label": "get",
+            "url": "./get"
+        },
+        {
+            "label": "set",
+            "url": "./set"
+        },
+        {
+            "label": "Graphics Handles",
+            "url": "/docs/plotting/graphics-handles"
+        },
+        {
+            "label": "Plot replay and export",
+            "url": "/docs/plotting/plot-replay-and-export"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/fill3.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/fill3.rs"
+    },
+    "gpu_residency": "`fill3` is a plotting sink and fusion barrier. GPU-resident coordinate inputs are gathered before patch construction because MATLAB-compatible parsing requires shape validation and polygon assembly.",
+    "gpu_behavior": [
+        "`fill3` shares patch rendering behavior, so host and gathered-GPU coordinate inputs produce the same patch objects and graphics handles.",
+        "Rendered geometry flows through the shared GPU plotting renderer after the patch objects are built.",
+        "A future direct GPU path should preserve the same `X,Y,Z,C` grouping and patch property semantics while replacing only the coordinate gathering and geometry packing stage."
+    ],
+    "key": "fill3",
+    "slug": "fill3",
+    "aliases": [],
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=fill3.js.map

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

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

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

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

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

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