runmat 0.3.5 → 0.4.0

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

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

package/dist/generated/builtins/loglog.js

@@ -0,0 +1,69 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "loglog",
+    "category": "plotting",
+    "keywords": [
+        "loglog",
+        "log-log plot",
+        "power law plot",
+        "matlab loglog",
+        "scaling analysis"
+    ],
+    "summary": "Plot data on logarithmic x and y axes for power laws, scaling analysis, and MATLAB `loglog` comparisons.",
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::loglog::tests"
+    },
+    "description": "`loglog` builds line objects through the shared RunMat line-plot path and then marks both axes as logarithmic. It is useful for power-law relationships, spectrum-style plots, and any comparison where both dimensions span multiple decades in the MATLAB `loglog` style.",
+    "behaviors": [
+        "The returned value is a numeric line handle.",
+        "Both x and y axes are switched to log scale on the active axes.",
+        "Axes scale state remains subplot-local.",
+        "Logarithmic axes are meaningful for positive-domain data on both x and y."
+    ],
+    "examples": [
+        {
+            "description": "Plot a power-law curve on logarithmic axes",
+            "input": "x = logspace(0, 3, 200);\nloglog(x, x.^(-1.5));"
+        },
+        {
+            "description": "Compare multiple scaling laws",
+            "input": "x = logspace(0, 3, 200);\nh1 = loglog(x, x.^(-1));\nset(h1, 'DisplayName', 'x^{-1}');\nhold on;\nh2 = loglog(x, x.^(-2));\nset(h2, 'DisplayName', 'x^{-2}');\nlegend;"
+        },
+        {
+            "description": "Inspect both axes after plotting",
+            "input": "x = logspace(0, 2, 50);\nloglog(x, x.^2);\nax = gca;\nxscale = get(ax, 'XScale');\nyscale = get(ax, 'YScale');",
+            "output": "% Both axes report 'log'"
+        }
+    ],
+    "links": [
+        {
+            "label": "plot",
+            "url": "./plot"
+        },
+        {
+            "label": "semilogx",
+            "url": "./semilogx"
+        },
+        {
+            "label": "semilogy",
+            "url": "./semilogy"
+        },
+        {
+            "label": "axis",
+            "url": "./axis"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/loglog.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/loglog.rs"
+    },
+    "key": "loglog",
+    "slug": "loglog",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=loglog.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loglog.js","sourceRoot":"","sources":["../../../src/generated/builtins/loglog.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,QAAQ;QACR,cAAc;QACd,gBAAgB;QAChB,eAAe;QACf,kBAAkB;KACnB;IACD,SAAS,EAAE,0GAA0G;IACrH,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,mCAAmC;KAC5C;IACD,aAAa,EAAE,6QAA6Q;IAC5R,WAAW,EAAE;QACX,8CAA8C;QAC9C,iEAAiE;QACjE,yCAAyC;QACzC,2EAA2E;KAC5E;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,iDAAiD;SAC3D;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,uKAAuK;SACjL;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,gHAAgH;YACzH,QAAQ,EAAE,0BAA0B;SACrC;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,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,6DAA6D;QACtE,KAAK,EAAE,0GAA0G;KAClH;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/logspace.js

@@ -0,0 +1,208 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "logspace",
+    "category": "array/creation",
+    "keywords": [
+        "logspace",
+        "logarithmic",
+        "vector",
+        "decade",
+        "gpu",
+        "frequency"
+    ],
+    "summary": "Generate logarithmically spaced row vectors that mirror MATLAB behavior.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Providers can compose `logspace` from `linspace`, scalar multiplication, and `unary_exp`. When hooks are missing, RunMat generates the sequence on the host and uploads it once to preserve residency."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::creation::logspace::tests",
+        "integration": "builtins::array::creation::logspace::tests::logspace_gpu_roundtrip",
+        "wgpu": "builtins::array::creation::logspace::tests::logspace_wgpu_matches_cpu"
+    },
+    "description": "`logspace(a, b, n)` returns `n` points that are equally spaced on a logarithmic scale between `10^a` and `10^b`. When `n` is omitted, MATLAB (and RunMat) default to 50 points. The result is always a `1 × n` row vector.",
+    "behaviors": [
+        "`logspace(a, b)` is equivalent to `logspace(a, b, 50)`.",
+        "`logspace(a, b, 0)` returns a `1 × 0` empty double row vector.",
+        "`logspace(a, b, 1)` returns `10^b`.",
+        "`logspace(a, b, 2)` returns `[10^a 10^b]`.",
+        "Endpoints may be real or complex scalars. Complex inputs produce complex outputs using the analytic definition `10^z = e^{z ln 10}`.",
+        "Scalar inputs may be numeric literals, `1×1` tensors, or gathered GPU scalars (`gpuArray` handles). Non-scalar inputs raise an error.",
+        "The third argument must be a finite, non-negative integer."
+    ],
+    "examples": [
+        {
+            "description": "Creating decades between 10 and 1000",
+            "input": "x = logspace(1, 3, 3)",
+            "output": "x = [10 100 1000]"
+        },
+        {
+            "description": "Generating logarithmic spacing with the default 50 points",
+            "input": "f = logspace(1, 4)",
+            "output": "% f is a 1x50 row vector spanning [10, 10^4]\ndisp(f(1));\ndisp(f(end))"
+        },
+        {
+            "description": "Requesting a single logarithmic sample",
+            "input": "edge = logspace(-3, 2, 1)",
+            "output": "edge = 100"
+        },
+        {
+            "description": "Building a swept frequency vector on the GPU",
+            "input": "lo = gpuArray(0);\nhi = gpuArray(3);\nfreq = logspace(lo, hi, 256);\nresp = sin(2*pi*freq)",
+            "output": "% freq and resp remain on the GPU when an acceleration provider is active.\ndisp(gather(freq(1:5)))"
+        },
+        {
+            "description": "Producing complex logarithmic spacing",
+            "input": "z = logspace(1+1i, 2+2i, 4)",
+            "output": "% Complex row vector with magnitudes and phases progressing logarithmically\ndisp(z)"
+        },
+        {
+            "description": "Matching MATLAB's legacy `logspace(a, pi, n)` syntax",
+            "input": "theta = logspace(-1, pi, 5)",
+            "output": "% Interprets pi literally: theta(end) == 10^pi\ndisp(theta(end))"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What base does `logspace` use?",
+            "answer": "RunMat follows MATLAB and always computes powers of ten. To use another base, build your own sequence (`base .^ linspace(...)`) or multiply the output by a constant factor."
+        },
+        {
+            "question": "Does `logspace` include both endpoints?",
+            "answer": "Yes. The first element is exactly `10^a` and the final element is exactly `10^b`, even when rounding errors could otherwise accumulate."
+        },
+        {
+            "question": "Can I request zero points?",
+            "answer": "Yes. `logspace(a, b, 0)` returns a `1 × 0` empty row vector."
+        },
+        {
+            "question": "What happens when `a` equals `b`?",
+            "answer": "Every element equals `10^a`. For example, `logspace(2, 2, 4)` returns `[100 100 100 100]`."
+        },
+        {
+            "question": "Does `logspace` support complex endpoints?",
+            "answer": "Yes. Real and imaginary components are interpolated independently, and the final values are computed using `10^z = e^{z ln 10}`."
+        },
+        {
+            "question": "Is the third argument required to be an integer?",
+            "answer": "Yes. Non-integer or negative counts raise an error, matching MATLAB semantics."
+        },
+        {
+            "question": "Does the function support GPU scalars?",
+            "answer": "Yes. GPU scalars are gathered once to determine the sequence, and the resulting vector is uploaded back to the device when profitable."
+        },
+        {
+            "question": "How accurate is the last element?",
+            "answer": "The implementation explicitly overwrites the final element with `10^b` to match MATLAB’s behavior and avoid floating-point drift."
+        },
+        {
+            "question": "How does `logspace` differ from `linspace`?",
+            "answer": "`linspace` spaces points linearly between two values, whereas `logspace` spaces points logarithmically between powers of ten."
+        },
+        {
+            "question": "Can I generate descending values?",
+            "answer": "Yes. `logspace(3, 1, 4)` returns `[1000 464.1589 215.4435 100]`, decreasing logarithmically."
+        }
+    ],
+    "links": [
+        {
+            "label": "linspace",
+            "url": "./linspace"
+        },
+        {
+            "label": "zeros",
+            "url": "./zeros"
+        },
+        {
+            "label": "ones",
+            "url": "./ones"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "colon",
+            "url": "./colon"
+        },
+        {
+            "label": "eye",
+            "url": "./eye"
+        },
+        {
+            "label": "false",
+            "url": "./false"
+        },
+        {
+            "label": "fill",
+            "url": "./fill"
+        },
+        {
+            "label": "magic",
+            "url": "./magic"
+        },
+        {
+            "label": "meshgrid",
+            "url": "./meshgrid"
+        },
+        {
+            "label": "rand",
+            "url": "./rand"
+        },
+        {
+            "label": "randi",
+            "url": "./randi"
+        },
+        {
+            "label": "randn",
+            "url": "./randn"
+        },
+        {
+            "label": "randperm",
+            "url": "./randperm"
+        },
+        {
+            "label": "range",
+            "url": "./range"
+        },
+        {
+            "label": "true",
+            "url": "./true"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/creation/logspace.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/creation/logspace.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` yourself in RunMat. When an acceleration provider is active and either endpoint already lives on the GPU, RunMat keeps the generated sequence on the device whenever the provider exposes the necessary hooks. If the hooks are missing, RunMat generates the vector on the host and uploads it once. This strategy preserves residency for subsequent kernels while avoiding partial GPU execution.",
+    "gpu_behavior": [
+        "When either endpoint already resides on the GPU, RunMat attempts to keep the sequence on the device. Providers that implement `linspace`, scalar multiplication, and `unary_exp` can build the vector entirely in device memory. If any hook is unavailable, RunMat generates the sequence on the host and performs a single upload, ensuring downstream kernels still receive a GPU tensor without surprising performance cliffs."
+    ],
+    "key": "logspace",
+    "slug": "logspace",
+    "categoryPath": [
+        "array",
+        "creation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=logspace.js.map

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

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

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

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

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

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

package/dist/generated/builtins/lower.js

@@ -0,0 +1,179 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "lower",
+    "category": "strings/transform",
+    "keywords": [
+        "lower",
+        "lowercase",
+        "convert to lowercase",
+        "string case",
+        "character arrays"
+    ],
+    "summary": "Convert strings, character arrays, and cell arrays of character vectors to lowercase.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/lower.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs on the CPU; if any element lives on the GPU, RunMat gathers it before converting."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::transform::lower::tests",
+        "integration": "builtins::strings::transform::lower::tests::lower_cell_array_mixed_content"
+    },
+    "description": "`lower(text)` converts every alphabetic character in `text` to lowercase. It accepts string scalars, string arrays, character arrays, and cell arrays of character vectors, mirroring MATLAB behaviour. Non-alphabetic characters are returned unchanged.",
+    "behaviors": [
+        "String inputs stay as strings. String arrays preserve their size, orientation, and missing values.",
+        "Character arrays are processed row by row. The result remains a rectangular char array; if any row grows after lowercasing (for example because `'İ'` expands), the array widens and shorter rows are padded with spaces.",
+        "Cell arrays must contain string scalars or character vectors. The result is a cell array of the same size with each element converted to lowercase, and other types raise MATLAB-compatible errors.",
+        "Missing string scalars (`string(missing)`) remain missing and are returned as `<missing>`.",
+        "Inputs that are numeric, logical, structs, or GPU tensors raise MATLAB-compatible type errors."
+    ],
+    "examples": [
+        {
+            "description": "Convert A String Scalar To Lowercase",
+            "input": "txt = \"RunMat\";\nresult = lower(txt)",
+            "output": "result = \"runmat\""
+        },
+        {
+            "description": "Lowercase Each Element Of A String Array",
+            "input": "labels = [\"NORTH\" \"South\"; \"EaSt\" \"WEST\"];\nlowered = lower(labels)",
+            "output": "lowered = 2×2 string\n    \"north\"    \"south\"\n    \"east\"     \"west\""
+        },
+        {
+            "description": "Lowercase Character Array Rows While Preserving Shape",
+            "input": "animals = char(\"CAT\", \"DOGE\");\nresult = lower(animals)",
+            "output": "result =\n\n  2×4 char array\n\n    'cat '\n    'doge'"
+        },
+        {
+            "description": "Lowercase A Cell Array Of Character Vectors",
+            "input": "C = {'HELLO', 'World'};\nout = lower(C)",
+            "output": "out = 1×2 cell array\n    {'hello'}    {'world'}"
+        },
+        {
+            "description": "Keep Missing Strings As Missing",
+            "input": "vals = string([\"DATA\" \"<missing>\" \"GPU\"]);\nconverted = lower(vals)",
+            "output": "converted = 1×3 string\n    \"data\"    <missing>    \"gpu\""
+        },
+        {
+            "description": "Lowercase Text Stored On A GPU Input",
+            "input": "codes = gpuArray(uint16('RUNMAT'));\ntxt = char(gather(codes));\nresult = lower(txt)",
+            "output": "result = 'runmat'"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `lower` change non-alphabetic characters?",
+            "answer": "No. Digits, punctuation, whitespace, and symbols remain untouched. Only alphabetic code points that have distinct lowercase forms are converted."
+        },
+        {
+            "question": "What happens to character array dimensions?",
+            "answer": "RunMat lowers each row independently and pads with spaces when a lowercase mapping increases the row length. This mirrors MATLAB’s behaviour so the result always has rectangular dimensions."
+        },
+        {
+            "question": "Can I pass numeric arrays to `lower`?",
+            "answer": "No. Passing numeric, logical, or struct inputs raises a MATLAB-compatible error. Convert the data to a string or character array first (for example with `string` or `char`)."
+        },
+        {
+            "question": "How are missing strings handled?",
+            "answer": "Missing string scalars remain `<missing>` and are returned unchanged. This matches MATLAB’s handling of missing values in text processing functions."
+        },
+        {
+            "question": "Will `lower` ever execute on the GPU?",
+            "answer": "Not today. The builtin gathers GPU-resident data automatically and performs the conversion on the CPU so the results match MATLAB exactly. Providers may add device-side kernels in the future, but the behaviour will stay compatible."
+        }
+    ],
+    "links": [
+        {
+            "label": "upper",
+            "url": "./upper"
+        },
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "char",
+            "url": "./char"
+        },
+        {
+            "label": "regexprep",
+            "url": "./regexprep"
+        },
+        {
+            "label": "strcmpi",
+            "url": "./strcmpi"
+        },
+        {
+            "label": "erase",
+            "url": "./erase"
+        },
+        {
+            "label": "eraseBetween",
+            "url": "./erasebetween"
+        },
+        {
+            "label": "extractBetween",
+            "url": "./extractbetween"
+        },
+        {
+            "label": "join",
+            "url": "./join"
+        },
+        {
+            "label": "pad",
+            "url": "./pad"
+        },
+        {
+            "label": "replace",
+            "url": "./replace"
+        },
+        {
+            "label": "split",
+            "url": "./split"
+        },
+        {
+            "label": "strcat",
+            "url": "./strcat"
+        },
+        {
+            "label": "strip",
+            "url": "./strip"
+        },
+        {
+            "label": "strrep",
+            "url": "./strrep"
+        },
+        {
+            "label": "strtrim",
+            "url": "./strtrim"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/transform/lower.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/transform/lower.rs"
+    },
+    "gpu_residency": "RunMat automatically keeps string data on the host for now. If text originates from GPU-based computations (for example as numeric code points stored on the device), `lower` gathers those values before applying the transformation, so you never need to call `gpuArray` explicitly for this builtin.",
+    "gpu_behavior": [
+        "`lower` executes on the CPU. When the input (or any nested element) resides on the GPU, RunMat gathers it to host memory before performing the conversion so results remain identical to MATLAB. Providers do not need to implement custom kernels for this builtin."
+    ],
+    "key": "lower",
+    "slug": "lower",
+    "categoryPath": [
+        "strings",
+        "transform"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=lower.js.map

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

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

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

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

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

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