runmat 0.4.1 → 0.4.3

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

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

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

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

package/dist/generated/builtins/blackman.js

@@ -0,0 +1,75 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "blackman",
+    "category": "math/signal",
+    "keywords": [
+        "blackman",
+        "window",
+        "signal processing",
+        "dsp",
+        "fft"
+    ],
+    "summary": "Generate a Blackman window as an N-by-1 real column vector.",
+    "description": "`blackman` generates Blackman windows for signal-processing workflows where lower spectral leakage is desired. RunMat supports the common MATLAB symmetric and periodic forms, including optional single-precision output.",
+    "behaviors": [
+        "`blackman(L)` returns an `L x 1` symmetric Blackman window.",
+        "`blackman(L, 'periodic')` returns the periodic form used in spectral-analysis workflows.",
+        "`blackman(..., 'single')` returns a single-precision window; `'double'` is the default.",
+        "If `L` is noninteger, RunMat rounds it to the nearest integer before constructing the window.",
+        "`blackman(0)` returns an empty `0 x 1` tensor.",
+        "`blackman(1)` returns `1`.",
+        "For the symmetric case and `L > 1`, coefficients follow `0.42 - 0.5*cos(2*pi*n/(L-1)) + 0.08*cos(4*pi*n/(L-1))`.",
+        "The periodic form is constructed by evaluating a symmetric window of length `L + 1` and dropping the final sample."
+    ],
+    "examples": [
+        {
+            "description": "Generate a short Blackman window",
+            "input": "w = blackman(8);\ndisp(w')"
+        },
+        {
+            "description": "Generate a periodic Blackman window",
+            "input": "w = blackman(8, 'periodic');\ndisp(w')"
+        },
+        {
+            "description": "Generate a single-precision Blackman window",
+            "input": "w = blackman(8, 'single');\nclass(w)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why would I use `blackman` instead of `hann` or `hamming`?",
+            "answer": "A Blackman window is often used when you want lower spectral leakage at the cost of a wider main lobe. It is a common tradeoff choice in spectral analysis workflows."
+        },
+        {
+            "question": "What is the difference between the symmetric and periodic Blackman window?",
+            "answer": "Use the symmetric form for filter-design style workflows. Use `'periodic'` for FFT-based spectral analysis, where RunMat constructs a symmetric window of length `L + 1` and removes the final sample."
+        },
+        {
+            "question": "Does `blackman` support single precision?",
+            "answer": "Yes. Pass `'single'` as the final option to request a single-precision output. The default output type is double precision."
+        }
+    ],
+    "links": [
+        {
+            "label": "hann",
+            "url": "./hann"
+        },
+        {
+            "label": "hamming",
+            "url": "./hamming"
+        },
+        {
+            "label": "fft",
+            "url": "./fft"
+        }
+    ],
+    "key": "blackman",
+    "slug": "blackman",
+    "categoryPath": [
+        "math",
+        "signal"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=blackman.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blackman.js","sourceRoot":"","sources":["../../../src/generated/builtins/blackman.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,QAAQ;QACR,mBAAmB;QACnB,KAAK;QACL,KAAK;KACN;IACD,SAAS,EAAE,6DAA6D;IACxE,aAAa,EAAE,4NAA4N;IAC3O,WAAW,EAAE;QACX,6DAA6D;QAC7D,0FAA0F;QAC1F,yFAAyF;QACzF,+FAA+F;QAC/F,gDAAgD;QAChD,4BAA4B;QAC5B,kHAAkH;QAClH,oHAAoH;KACrH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,4BAA4B;SACtC;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,wCAAwC;SAClD;QACD;YACE,aAAa,EAAE,6CAA6C;YAC5D,OAAO,EAAE,sCAAsC;SAChD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,4DAA4D;YACxE,QAAQ,EAAE,uKAAuK;SAClL;QACD;YACE,UAAU,EAAE,4EAA4E;YACxF,QAAQ,EAAE,wMAAwM;SACnN;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,6HAA6H;SACxI;KACF;IACD,OAAO,EAAE;QACP;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;KACF;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/datetime.js

@@ -0,0 +1,150 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "datetime",
+    "category": "datetime",
+    "keywords": [
+        "datetime",
+        "date",
+        "time",
+        "serial date number",
+        "datenum",
+        "Format",
+        "MATLAB compatibility"
+    ],
+    "summary": "Create MATLAB-compatible datetime arrays from components, text, or serial date numbers.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/datetime.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "datetime values are host-side objects backed by serial date tensors; there is no GPU-resident datetime type."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "integration": "runmat-ignition/tests/datetime.rs"
+    },
+    "description": "`datetime` constructs MATLAB-style datetime objects. RunMat currently supports creation from year-month-day component inputs, from text scalars or text arrays, from serial date numbers, and from numeric inputs marked with `ConvertFrom='datenum'`. The resulting object stores serial dates internally and exposes a writable `Format` property used by display, `string`, and `char` conversion.",
+    "behaviors": [
+        "`datetime()` with no arguments returns the current local date and time.",
+        "`datetime(Y, M, D)` and `datetime(Y, M, D, H, MN, S)` construct datetimes from numeric components. Scalar inputs expand to match non-scalar component arrays.",
+        "`datetime(text)` accepts string scalars, string arrays, and character vectors. Supported text includes common ISO-like forms, `dd-MMM-yyyy` forms, and `now`.",
+        "`datetime(serials, 'ConvertFrom', 'datenum')` interprets numeric values as MATLAB serial date numbers.",
+        "`datetime(serials)` also accepts raw serial date numbers for the current implementation, producing datetime values directly from those serials.",
+        "The `Format` property controls text rendering. Assigning `t.Format = 'yyyy-MM-dd HH:mm:ss'` updates how the object displays without changing the stored point in time.",
+        "Linear indexing `t(k)` is supported and returns datetime values.",
+        "Comparison operators and `plus`/`minus` day arithmetic are supported. Subtracting two datetime values returns numeric day deltas."
+    ],
+    "examples": [
+        {
+            "description": "Constructing a scalar datetime from numeric components",
+            "input": "t = datetime(2024, 4, 9, 13, 30, 0)",
+            "output": "t =\n  09-Apr-2024 13:30:00"
+        },
+        {
+            "description": "Parsing text into datetimes",
+            "input": "t = datetime([\"2024-04-09 13:30:00\"; \"2024-04-10 08:15:00\"])",
+            "output": "t =\n09-Apr-2024 13:30:00\n10-Apr-2024 08:15:00"
+        },
+        {
+            "description": "Creating datetimes from serial date numbers",
+            "input": "d = datetime([739351; 739352], 'ConvertFrom', 'datenum')",
+            "output": "d =\n09-Apr-2024 00:00:00\n10-Apr-2024 00:00:00"
+        },
+        {
+            "description": "Changing display format without changing the stored value",
+            "input": "t = datetime(2024, 4, 9, 13, 30, 0);\nt.Format = 'yyyy-MM-dd HH:mm:ss';\ndisp(t)",
+            "output": "2024-04-09 13:30:00"
+        },
+        {
+            "description": "Extracting calendar and clock components",
+            "input": "t = datetime(2024, 4, 9, 13, 30, 5);\ny = year(t)\nm = month(t)\nd = day(t)\nh = hour(t)",
+            "output": "y = 2024\nm = 4\nd = 9\nh = 13"
+        },
+        {
+            "description": "Adding days and subtracting datetimes",
+            "input": "t0 = datetime(2024, 4, 9);\nt1 = t0 + 7;\ndelta = t1 - t0",
+            "output": "delta = 7"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What does the `Format` property change?",
+            "answer": "Only the textual representation. The stored serial date number is unchanged, so comparisons and arithmetic still refer to the same instant."
+        },
+        {
+            "question": "How is subtraction interpreted?",
+            "answer": "Subtracting one datetime from another returns a numeric delta measured in days. Subtracting a numeric value from a datetime shifts it backward by that many days."
+        },
+        {
+            "question": "Can I index datetime arrays?",
+            "answer": "Yes. Linear `()` indexing is supported and preserves the datetime type."
+        },
+        {
+            "question": "Does `datetime` run on the GPU?",
+            "answer": "No. datetime values are represented as host-side objects. Numeric inputs may be gathered first, but the resulting datetime object remains on the CPU."
+        }
+    ],
+    "links": [
+        {
+            "label": "year",
+            "url": "./year"
+        },
+        {
+            "label": "month",
+            "url": "./month"
+        },
+        {
+            "label": "day",
+            "url": "./day"
+        },
+        {
+            "label": "hour",
+            "url": "./hour"
+        },
+        {
+            "label": "minute",
+            "url": "./minute"
+        },
+        {
+            "label": "second",
+            "url": "./second"
+        },
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "disp",
+            "url": "./disp"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/datetime/mod.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/datetime/mod.rs"
+    },
+    "gpu_residency": "No. RunMat represents `datetime` values as host-side objects with an internal serial-date tensor and a `Format` property. Even when the constructor receives gathered numeric data, the resulting object remains resident on the CPU.",
+    "gpu_behavior": [
+        "`datetime` does not allocate GPU objects or invoke provider kernels. If a numeric input originates on the GPU, RunMat gathers it before building the datetime object."
+    ],
+    "key": "datetime",
+    "slug": "datetime",
+    "categoryPath": [
+        "datetime"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=datetime.js.map

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

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

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

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

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

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

package/dist/generated/builtins/duration.js

@@ -0,0 +1,118 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "duration",
+    "category": "datetime",
+    "keywords": [
+        "duration",
+        "elapsed time",
+        "time span",
+        "Format",
+        "MATLAB compatibility"
+    ],
+    "summary": "Create MATLAB-compatible duration arrays from hour, minute, and second components.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/duration.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "duration values are host-side objects backed by day-count tensors; there is no GPU-resident duration type."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::duration::tests"
+    },
+    "description": "`duration` constructs MATLAB-style duration objects from numeric hour, minute, and second components. Scalar component inputs expand to match non-scalar arrays, the resulting object stores elapsed time internally as days, and the writable `Format` property controls display, `string`, and `char` conversion.",
+    "behaviors": [
+        "`duration(H)` treats the input as hours.",
+        "`duration(H, M)` treats the inputs as hours and minutes.",
+        "`duration(H, M, S)` treats the inputs as hours, minutes, and seconds.",
+        "Scalar component inputs broadcast to match non-scalar component arrays; non-scalar inputs must share the same shape.",
+        "The `Format` property controls text rendering. Supported values are `hh:mm:ss`, `hh:mm`, `mm:ss`, `s`, and `ss`.",
+        "Linear indexing `d(k)` is supported and returns duration values.",
+        "Comparison operators and `plus`/`minus` duration arithmetic are supported.",
+        "Adding a duration to a datetime returns a datetime shifted by that elapsed time."
+    ],
+    "examples": [
+        {
+            "description": "Constructing a scalar duration from numeric components",
+            "input": "t = duration(1, 30, 45)",
+            "output": "t =\n  01:30:45"
+        },
+        {
+            "description": "Broadcasting scalar minutes across an hour vector",
+            "input": "t = duration([1 2], 15)",
+            "output": "t =\n01:15:00  02:15:00"
+        },
+        {
+            "description": "Changing the display format without changing the stored value",
+            "input": "t = duration(1, 5, 0);\nt.Format = 'hh:mm';\ndisp(t)",
+            "output": "01:05"
+        },
+        {
+            "description": "Adding a duration to a datetime",
+            "input": "t0 = datetime(2024, 4, 9, 8, 0, 0);\nt1 = t0 + duration(1, 30, 0)",
+            "output": "t1 =\n  09-Apr-2024 09:30:00"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What does the `Format` property change?",
+            "answer": "Only the textual representation. The stored elapsed time is unchanged, so comparisons and arithmetic still refer to the same duration."
+        },
+        {
+            "question": "Can I index duration arrays?",
+            "answer": "Yes. Linear `()` indexing is supported and preserves the duration type."
+        },
+        {
+            "question": "Does `duration` run on the GPU?",
+            "answer": "No. duration values are represented as host-side objects. Numeric inputs may be gathered first, but the resulting duration object remains on the CPU."
+        },
+        {
+            "question": "Can I add a duration to a datetime?",
+            "answer": "Yes. RunMat supports `datetime + duration` and returns a datetime shifted by the specified elapsed time."
+        }
+    ],
+    "links": [
+        {
+            "label": "datetime",
+            "url": "./datetime"
+        },
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "disp",
+            "url": "./disp"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/duration/mod.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/duration/mod.rs"
+    },
+    "gpu_residency": "No. RunMat represents `duration` values as host-side objects with an internal day-count tensor and a `Format` property. Even when the constructor receives gathered numeric data, the resulting object remains resident on the CPU.",
+    "gpu_behavior": [
+        "`duration` does not allocate GPU objects or invoke provider kernels. If a numeric input originates on the GPU, RunMat gathers it before building the duration object."
+    ],
+    "key": "duration",
+    "slug": "duration",
+    "categoryPath": [
+        "datetime"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=duration.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"duration.js","sourceRoot":"","sources":["../../../src/generated/builtins/duration.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,cAAc;QACd,WAAW;QACX,QAAQ;QACR,sBAAsB;KACvB;IACD,SAAS,EAAE,oFAAoF;IAC/F,YAAY,EAAE;QACZ,yDAAyD;KAC1D;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,4GAA4G;KACtH;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,2BAA2B;KACpC;IACD,aAAa,EAAE,qTAAqT;IACpU,WAAW,EAAE;QACX,0CAA0C;QAC1C,0DAA0D;QAC1D,uEAAuE;QACvE,sHAAsH;QACtH,kHAAkH;QAClH,kEAAkE;QAClE,4EAA4E;QAC5E,kFAAkF;KACnF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,wDAAwD;YACvE,OAAO,EAAE,yBAAyB;YAClC,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,yBAAyB;YAClC,QAAQ,EAAE,yBAAyB;SACpC;QACD;YACE,aAAa,EAAE,+DAA+D;YAC9E,OAAO,EAAE,sDAAsD;YAC/D,QAAQ,EAAE,OAAO;SAClB;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,mEAAmE;YAC5E,QAAQ,EAAE,8BAA8B;SACzC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,wIAAwI;SACnJ;QACD;YACE,UAAU,EAAE,8BAA8B;YAC1C,QAAQ,EAAE,yEAAyE;SACpF;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,uJAAuJ;SAClK;QACD;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,0GAA0G;SACrH;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,sDAAsD;QAC/D,KAAK,EAAE,mGAAmG;KAC3G;IACD,eAAe,EAAE,qOAAqO;IACtP,cAAc,EAAE;QACd,uKAAuK;KACxK;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/hamming.js

@@ -0,0 +1,70 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "hamming",
+    "category": "math/signal",
+    "keywords": [
+        "hamming",
+        "window",
+        "signal processing",
+        "dsp",
+        "fft"
+    ],
+    "summary": "Generate a Hamming window as an N-by-1 real column vector.",
+    "description": "`hamming` generates Hamming windows for signal-processing workflows such as spectral analysis and filter design. RunMat supports the standard MATLAB symmetric and periodic forms.",
+    "behaviors": [
+        "`hamming(L)` returns an `L x 1` symmetric Hamming window.",
+        "`hamming(L, 'periodic')` returns the periodic form used in spectral-analysis workflows.",
+        "If `L` is noninteger, RunMat rounds it to the nearest integer before constructing the window.",
+        "`hamming(0)` returns an empty `0 x 1` tensor.",
+        "`hamming(1)` returns `1`.",
+        "For the symmetric case and `L > 1`, coefficients follow `0.54 - 0.46*cos(2*pi*n/(L-1))`.",
+        "The periodic form is constructed by evaluating a symmetric window of length `L + 1` and dropping the final sample."
+    ],
+    "examples": [
+        {
+            "description": "Generate a short Hamming window",
+            "input": "w = hamming(8);\ndisp(w')"
+        },
+        {
+            "description": "Generate a periodic Hamming window",
+            "input": "w = hamming(8, 'periodic');\ndisp(w')"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I use the periodic Hamming window?",
+            "answer": "Use `'periodic'` when the window will be paired with FFT-based spectral analysis. The periodic form is built from a symmetric window of length `L + 1` with the final sample removed."
+        },
+        {
+            "question": "What shape does `hamming(L)` return?",
+            "answer": "It returns an `L x 1` column vector."
+        },
+        {
+            "question": "Does RunMat support a `typeName` overload for `hamming`?",
+            "answer": "RunMat currently implements the documented `hamming(L)` and `hamming(L, sflag)` forms."
+        }
+    ],
+    "links": [
+        {
+            "label": "hann",
+            "url": "./hann"
+        },
+        {
+            "label": "blackman",
+            "url": "./blackman"
+        },
+        {
+            "label": "fft",
+            "url": "./fft"
+        }
+    ],
+    "key": "hamming",
+    "slug": "hamming",
+    "categoryPath": [
+        "math",
+        "signal"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=hamming.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hamming.js","sourceRoot":"","sources":["../../../src/generated/builtins/hamming.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,QAAQ;QACR,mBAAmB;QACnB,KAAK;QACL,KAAK;KACN;IACD,SAAS,EAAE,4DAA4D;IACvE,aAAa,EAAE,oLAAoL;IACnM,WAAW,EAAE;QACX,2DAA2D;QAC3D,yFAAyF;QACzF,+FAA+F;QAC/F,+CAA+C;QAC/C,2BAA2B;QAC3B,0FAA0F;QAC1F,oHAAoH;KACrH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,2BAA2B;SACrC;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,uCAAuC;SACjD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,gDAAgD;YAC5D,QAAQ,EAAE,uLAAuL;SAClM;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,sCAAsC;SACjD;QACD;YACE,UAAU,EAAE,0DAA0D;YACtE,QAAQ,EAAE,wFAAwF;SACnG;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/hann.js

@@ -0,0 +1,75 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "hann",
+    "category": "math/signal",
+    "keywords": [
+        "hann",
+        "window",
+        "signal processing",
+        "dsp",
+        "fft"
+    ],
+    "summary": "Generate a Hann window as an N-by-1 real column vector.",
+    "description": "`hann` generates Hann windows for signal-processing workflows such as spectral analysis and filter design. RunMat supports the common MATLAB call forms for symmetric and periodic windows, including optional single-precision output.",
+    "behaviors": [
+        "`hann(L)` returns an `L x 1` symmetric Hann window.",
+        "`hann(L, 'periodic')` returns the periodic form used in spectral-analysis workflows.",
+        "`hann(..., 'single')` returns a single-precision window; `'double'` is the default.",
+        "If `L` is noninteger, RunMat rounds it to the nearest integer before constructing the window.",
+        "`hann(0)` returns an empty `0 x 1` tensor.",
+        "`hann(1)` returns `1`.",
+        "For the symmetric case and `L > 1`, coefficients follow `0.5 - 0.5*cos(2*pi*n/(L-1))`.",
+        "The periodic form is constructed by evaluating a symmetric window of length `L + 1` and dropping the final sample."
+    ],
+    "examples": [
+        {
+            "description": "Generate a short Hann window",
+            "input": "w = hann(8);\ndisp(w')"
+        },
+        {
+            "description": "Generate a periodic Hann window for spectral analysis",
+            "input": "w = hann(8, 'periodic');\ndisp(w')"
+        },
+        {
+            "description": "Generate a single-precision Hann window",
+            "input": "w = hann(8, 'single');\nclass(w)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What is the difference between the symmetric and periodic Hann window?",
+            "answer": "Use the default symmetric window for filter-design style workflows. Use `'periodic'` for spectral analysis, where MATLAB and RunMat construct a symmetric window of length `L + 1` and drop the last sample so the sequence matches the periodicity assumptions of the DFT."
+        },
+        {
+            "question": "What shape does `hann(L)` return?",
+            "answer": "It returns an `L x 1` column vector, matching MATLAB's window-function convention."
+        },
+        {
+            "question": "Does `hann` support single precision?",
+            "answer": "Yes. Pass `'single'` as the final option to request a single-precision output. The default output type is double precision."
+        }
+    ],
+    "links": [
+        {
+            "label": "hamming",
+            "url": "./hamming"
+        },
+        {
+            "label": "blackman",
+            "url": "./blackman"
+        },
+        {
+            "label": "fft",
+            "url": "./fft"
+        }
+    ],
+    "key": "hann",
+    "slug": "hann",
+    "categoryPath": [
+        "math",
+        "signal"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=hann.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hann.js","sourceRoot":"","sources":["../../../src/generated/builtins/hann.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,MAAM;QACN,QAAQ;QACR,mBAAmB;QACnB,KAAK;QACL,KAAK;KACN;IACD,SAAS,EAAE,yDAAyD;IACpE,aAAa,EAAE,yOAAyO;IACxP,WAAW,EAAE;QACX,qDAAqD;QACrD,sFAAsF;QACtF,qFAAqF;QACrF,+FAA+F;QAC/F,4CAA4C;QAC5C,wBAAwB;QACxB,wFAAwF;QACxF,oHAAoH;KACrH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,wBAAwB;SAClC;QACD;YACE,aAAa,EAAE,uDAAuD;YACtE,OAAO,EAAE,oCAAoC;SAC9C;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,kCAAkC;SAC5C;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,wEAAwE;YACpF,QAAQ,EAAE,6QAA6Q;SACxR;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,oFAAoF;SAC/F;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,6HAA6H;SACxI;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,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/nextpow2.js

@@ -0,0 +1,71 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "nextpow2",
+    "category": "math/elementwise",
+    "keywords": [
+        "nextpow2",
+        "power of two",
+        "fft",
+        "zero padding",
+        "gpu"
+    ],
+    "summary": "Return the exponent p such that 2^p is the next power of two greater than or equal to abs(n).",
+    "description": "`nextpow2(X)` applies the standard power-of-two exponent transform elementwise, returning `ceil(log2(abs(X)))` with zero mapped to zero. This is commonly used in FFT workflows such as `2^nextpow2(length(x))`.",
+    "behaviors": [
+        "`nextpow2` accepts real numeric scalars and tensors.",
+        "The transform is applied elementwise for array inputs.",
+        "Zero maps to `0`.",
+        "Negative values use `abs(X)` before computing the exponent.",
+        "`Inf` remains infinite and `NaN` remains `NaN`.",
+        "GPU tensors use a unary provider hook when available and otherwise gather to the host.",
+        "The output preserves the input's scalar/tensor shape."
+    ],
+    "examples": [
+        {
+            "description": "Compute an FFT-friendly zero-padding length",
+            "input": "x = rand(1000, 1);\nN = 2^nextpow2(length(x))"
+        },
+        {
+            "description": "Apply nextpow2 elementwise to an array",
+            "input": "p = nextpow2([0 1 3 9])",
+            "output": "p = [0 0 2 4]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why does `nextpow2` return an exponent instead of the actual power of two?",
+            "answer": "That matches MATLAB semantics. To get the actual power of two, use `2^nextpow2(x)` for a scalar or `2.^nextpow2(X)` elementwise for arrays."
+        },
+        {
+            "question": "How is `nextpow2` used in FFT workflows?",
+            "answer": "A common pattern is `N = 2^nextpow2(length(x))`, which computes a power-of-two transform length suitable for zero padding before an FFT."
+        },
+        {
+            "question": "Does `nextpow2` preserve array shape?",
+            "answer": "Yes. The transform is elementwise and the output has the same scalar/tensor shape as the input."
+        }
+    ],
+    "links": [
+        {
+            "label": "fft",
+            "url": "./fft"
+        },
+        {
+            "label": "pow2",
+            "url": "./pow2"
+        },
+        {
+            "label": "length",
+            "url": "./length"
+        }
+    ],
+    "key": "nextpow2",
+    "slug": "nextpow2",
+    "categoryPath": [
+        "math",
+        "elementwise"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=nextpow2.js.map