runmat 0.3.5 → 0.4.0

package/dist/generated/builtins/length.js

@@ -0,0 +1,156 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "length",
+    "category": "array/introspection",
+    "keywords": [
+        "length",
+        "largest dimension",
+        "vector length",
+        "gpu metadata",
+        "array size"
+    ],
+    "summary": "Return the length of the largest dimension of scalars, vectors, matrices, and N-D arrays.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Reads tensor metadata from handles; falls back to host when provider metadata is incomplete."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::introspection::length::tests",
+        "integration": "builtins::array::introspection::length::tests::length_gpu_tensor_reads_shape"
+    },
+    "description": "`length(A)` returns the length of the largest dimension of `A`. Scalars report `1`, column vectors report their row count, row vectors return their column count, and rectangular matrices yield the larger of their row or column dimensions. For higher-rank arrays, the function returns the maximum extent across every dimension.",
+    "behaviors": [
+        "The result is always a double-precision scalar.",
+        "Empty arrays report `0` when every dimension is zero; otherwise the maximum non-zero dimension is reported (e.g., `0×5` arrays have length `5`).",
+        "Character arrays and string arrays follow their array dimensions, not the number of code points.",
+        "Cell arrays use their MATLAB array shape (`rows × cols`) with the maximum dimension returned.",
+        "GPU-resident arrays are inspected without gathering when the provider populates shape metadata on the tensor handle; otherwise, RunMat gathers once to recover the correct dimensions.",
+        "Arguments that are not arrays (scalars, logicals, strings, handle objects) are treated as `1×1`."
+    ],
+    "examples": [
+        {
+            "description": "Determine the length of a row vector",
+            "input": "row = [1 2 3 4];\nn = length(row)",
+            "output": "n = 4"
+        },
+        {
+            "description": "Find the longer side of a rectangular matrix",
+            "input": "A = randn(5, 12);\nlen = length(A)",
+            "output": "len = 12"
+        },
+        {
+            "description": "Handle empty arrays that still have a non-zero dimension",
+            "input": "E = zeros(0, 7);\nlen = length(E)",
+            "output": "len = 7"
+        },
+        {
+            "description": "Measure the length of a character array",
+            "input": "name = 'RunMat';\nlen = length(name)",
+            "output": "len = 6"
+        },
+        {
+            "description": "Inspect the length of a gpuArray without gathering",
+            "input": "G = gpuArray(ones(256, 4));\nlen = length(G)",
+            "output": "len = 256"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How is `length` different from `size`?",
+            "answer": "`length(A)` returns the maximum dimension length as a scalar, whereas `size(A)` returns every dimension in a row vector. Use `length` when you only care about the longest dimension."
+        },
+        {
+            "question": "What does `length` return for scalars?",
+            "answer": "Scalars are treated as `1×1`, so `length(scalar)` returns `1`."
+        },
+        {
+            "question": "How does `length` behave for empty arrays?",
+            "answer": "If all dimensions are zero, `length` returns `0`. If any dimension is non-zero, the maximum dimension is returned. For example, `zeros(0, 5)` has length `5`, but `zeros(0, 0)` has length `0`."
+        },
+        {
+            "question": "Does `length` gather GPU data?",
+            "answer": "No. The runtime relies on shape metadata stored in the GPU tensor handle. Only when that metadata is missing does RunMat gather the tensor to maintain correctness."
+        },
+        {
+            "question": "Can I use `length` on cell arrays and structs?",
+            "answer": "Yes. `length` examines the MATLAB array shape of the container, so cell arrays and struct arrays return the maximum dimension of their array layout."
+        },
+        {
+            "question": "Does `length` count characters or bytes?",
+            "answer": "For character arrays, the length reflects the array dimensions (rows and columns), not encoded byte length or Unicode scalar counts."
+        },
+        {
+            "question": "What about string arrays?",
+            "answer": "String arrays are treated like any other array. String scalars are `1×1`, so `length(\"abc\")` returns `1`. Use `strlength` if you need the number of characters in each element."
+        },
+        {
+            "question": "Is `length` safe to use inside fused GPU expressions?",
+            "answer": "Yes. `length` never allocates or keeps data on the GPU. It returns a host scalar immediately, so it won't break fusion plans."
+        }
+    ],
+    "links": [
+        {
+            "label": "size",
+            "url": "./size"
+        },
+        {
+            "label": "numel",
+            "url": "./numel"
+        },
+        {
+            "label": "strlength",
+            "url": "./strlength"
+        },
+        {
+            "label": "isempty",
+            "url": "./isempty"
+        },
+        {
+            "label": "ismatrix",
+            "url": "./ismatrix"
+        },
+        {
+            "label": "isscalar",
+            "url": "./isscalar"
+        },
+        {
+            "label": "isvector",
+            "url": "./isvector"
+        },
+        {
+            "label": "ndims",
+            "url": "./ndims"
+        },
+        {
+            "label": "numel",
+            "url": "./numel"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/introspection/length.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/introspection/length.rs"
+    },
+    "gpu_behavior": [
+        "`length` is a metadata query. When the input is a GPU tensor, RunMat looks at the shape embedded in the GPU handle (`GpuTensorHandle.shape`). If the active provider leaves that metadata empty, the runtime invokes `provider.download(handle)` a single time to recover the shape, ensuring MATLAB-compatible behaviour. No GPU kernels are launched and no device buffers are allocated by this builtin."
+    ],
+    "key": "length",
+    "slug": "length",
+    "categoryPath": [
+        "array",
+        "introspection"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=length.js.map

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

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

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

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

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

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

package/dist/generated/builtins/linsolve.js

@@ -0,0 +1,168 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "linsolve",
+    "category": "math/linalg/solve",
+    "keywords": [
+        "linsolve",
+        "linear solve",
+        "triangular system",
+        "posdef",
+        "gpu"
+    ],
+    "summary": "Solve linear systems A * X = B with optional structural hints (triangular, symmetric, positive-definite, or transposed).",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/linsolve.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Prefers the accel provider's linsolve hook; the current WGPU backend downloads operands to the host, runs the shared solver, then re-uploads the result to preserve GPU residency."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "uniform"
+    },
+    "requires_feature": "wgpu",
+    "tested": {
+        "unit": "builtins::math::linalg::solve::linsolve::tests",
+        "gpu": "builtins::math::linalg::solve::linsolve::tests::gpu_round_trip_matches_cpu",
+        "wgpu": "builtins::math::linalg::solve::linsolve::tests::wgpu_round_trip_matches_cpu"
+    },
+    "description": "`X = linsolve(A, B)` solves the linear system `A * X = B`. The optional `opts` structure lets you declare that `A` is lower- or upper-triangular, symmetric, positive-definite, rectangular, or that the transposed system should be solved instead. These hints mirror MATLAB and allow the runtime to skip unnecessary factorizations.",
+    "behaviors": [
+        "Inputs must behave like 2-D matrices (trailing singleton dimensions are accepted). `size(A, 1)` must match `size(B, 1)` after accounting for `opts.TRANSA`.",
+        "When `opts.LT` or `opts.UT` are supplied, `linsolve` performs forward/back substitution instead of a full factorization. Singular pivots trigger the MATLAB error `\"linsolve: matrix is singular to working precision.\"`",
+        "`opts.TRANSA = 'T'` or `'C'` solves `Aᵀ * X = B` (conjugate transpose for complex matrices).",
+        "`opts.POSDEF` and `opts.SYM` are accepted for compatibility; the current implementation still falls back to the SVD-based dense solver when a specialised route is not yet wired in.",
+        "The optional second output `[X, rcond_est] = linsolve(...)` (exposed via the VM multi-output path) returns the estimated reciprocal condition number used to honour `opts.RCOND`.",
+        "Logical and integer inputs are promoted to double precision. Complex inputs are handled in complex arithmetic."
+    ],
+    "examples": [
+        {
+            "description": "Solving a 2×2 linear system",
+            "input": "A = [4 -2; 1 3];\nb = [6; 7];\nx = linsolve(A, b)",
+            "output": "x =\n     2\n     1"
+        },
+        {
+            "description": "Using a lower-triangular hint",
+            "input": "L = [3 0 0; -1 2 0; 4 1 5];\nb = [9; 1; 12];\nopts.LT = true;\nx = linsolve(L, b, opts)",
+            "output": "x =\n     3\n     2\n     1"
+        },
+        {
+            "description": "Solving the transposed system",
+            "input": "A = [2 1 0; 0 3 4; 0 0 5];\nb = [3; 11; 5];\nopts.UT = true;\nopts.TRANSA = 'T';\nx = linsolve(A, b, opts)",
+            "output": "x =\n     1\n     2\n     1"
+        },
+        {
+            "description": "Complex triangular solve",
+            "input": "U = [2+1i  -1i; 0  4-2i];\nb = [3+2i; 7];\nopts.UT = true;\nx = linsolve(U, b, opts)",
+            "output": "x =\n   2.0000 + 0.0000i\n   1.7500 + 0.8750i"
+        },
+        {
+            "description": "Estimating the reciprocal condition number",
+            "input": "A = [1 1; 1 1+1e-12];\nb = [2; 2+1e-12];\n[x, rcond_est] = linsolve(A, b)",
+            "output": "x =\n     1\n     1\n\nrcond_est =\n    4.4409e-12"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What happens if I pass both `opts.LT` and `opts.UT`?",
+            "answer": "RunMat raises the MATLAB error `\"linsolve: LT and UT are mutually exclusive.\"`—a matrix cannot be simultaneously strictly lower- and upper-triangular."
+        },
+        {
+            "question": "Does `opts.TRANSA` accept lowercase characters?",
+            "answer": "Yes. `opts.TRANSA` is case-insensitive and accepts `'N'`, `'T'`, `'C'`, or their lowercase variants. `'C'` and `'T'` are equivalent for real matrices; `'C'` takes the conjugate transpose for complex matrices (mirroring MATLAB)."
+        },
+        {
+            "question": "How is `opts.RCOND` used?",
+            "answer": "`opts.RCOND` provides a lower bound on the acceptable reciprocal condition number. If the estimated `rcond` falls below the requested threshold the builtin raises `\"linsolve: matrix is singular to working precision.\"`"
+        },
+        {
+            "question": "Do `opts.SYM` or `opts.POSDEF` change the algorithm today?",
+            "answer": "They are accepted for MATLAB compatibility. The current implementation still uses the dense SVD solver when no specialised routine is wired in; future work will route positive-definite systems to Cholesky-based kernels."
+        },
+        {
+            "question": "Can I use higher-dimensional arrays?",
+            "answer": "Inputs must behave like matrices. Trailing singleton dimensions are permitted, but other higher-rank arrays should be reshaped before calling `linsolve`, just like in MATLAB."
+        }
+    ],
+    "links": [
+        {
+            "label": "mldivide",
+            "url": "./mldivide"
+        },
+        {
+            "label": "mrdivide",
+            "url": "./mrdivide"
+        },
+        {
+            "label": "lu",
+            "url": "./lu"
+        },
+        {
+            "label": "chol",
+            "url": "./chol"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "cond",
+            "url": "./cond"
+        },
+        {
+            "label": "det",
+            "url": "./det"
+        },
+        {
+            "label": "inv",
+            "url": "./inv"
+        },
+        {
+            "label": "norm",
+            "url": "./norm"
+        },
+        {
+            "label": "pinv",
+            "url": "./pinv"
+        },
+        {
+            "label": "rank",
+            "url": "./rank"
+        },
+        {
+            "label": "rcond",
+            "url": "./rcond"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/linalg/solve/linsolve.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/linalg/solve/linsolve.rs"
+    },
+    "gpu_residency": "No additional residency management is required. When both operands already reside on the GPU, RunMat executes the provider's `linsolve` hook. The current WGPU backend gathers the data to the host, runs the shared solver, and re-uploads the output automatically, so downstream GPU work keeps its residency. Providers that implement an on-device kernel can execute entirely on the GPU without any MATLAB-level changes.",
+    "gpu_behavior": [
+        "When a gpuArray provider is active, RunMat offers the solve to its `linsolve` hook. The current WGPU backend downloads the operands to the host, executes the shared CPU solver, and uploads the result back to the device so downstream kernels retain their residency. If no provider is registered—or a provider declines the hook—RunMat gathers inputs to the host and returns a host tensor."
+    ],
+    "key": "linsolve",
+    "slug": "linsolve",
+    "categoryPath": [
+        "math",
+        "linalg",
+        "solve"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=linsolve.js.map

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

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

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

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

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

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

package/dist/generated/builtins/linspace.js

@@ -0,0 +1,217 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "linspace",
+    "category": "array/creation",
+    "keywords": [
+        "linspace",
+        "range",
+        "vector",
+        "gpu",
+        "sequence"
+    ],
+    "summary": "Generate linearly spaced row vectors that match MATLAB behaviour.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Uses provider `linspace` hooks when available (implemented by the WGPU backend); otherwise falls back to uploading a host-generated sequence to keep residency intact."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::creation::linspace::tests",
+        "integration": "builtins::array::creation::linspace::tests::linspace_gpu_roundtrip",
+        "wgpu": "builtins::array::creation::linspace::tests::linspace_wgpu_matches_cpu"
+    },
+    "description": "`linspace(a, b, n)` returns `n` linearly spaced points between the start point `a` and the end point `b`, inclusive. When `n` is omitted, MATLAB (and RunMat) default to 100 points. The result is always a row vector.",
+    "behaviors": [
+        "`linspace(a, b)` is equivalent to `linspace(a, b, 100)`.",
+        "`linspace(a, b, 0)` returns a `1×0` empty double row vector.",
+        "`linspace(a, b, 1)` returns `b`.",
+        "`linspace(a, b, 2)` returns `[a b]`.",
+        "Complex end points are supported; the real and imaginary parts are interpolated independently.",
+        "Inputs may be scalars, `1×1` tensors, or GPU scalars (`gpuArray` handles).",
+        "The third argument must be a finite, non-negative integer."
+    ],
+    "examples": [
+        {
+            "description": "Creating five points between zero and one",
+            "input": "x = linspace(0, 1, 5)",
+            "output": "% Row vector with five equally spaced points\nx = [0 0.25 0.5 0.75 1]"
+        },
+        {
+            "description": "Sampling 100 points when the third argument is omitted",
+            "input": "t = linspace(-pi, pi)",
+            "output": "% t is a 1x100 row vector spanning [-pi, pi]\ndisp(t(1));\ndisp(t(end))"
+        },
+        {
+            "description": "Constructing complex breakpoints",
+            "input": "z = linspace(1+1i, -3+2i, 4)",
+            "output": "z =\n   1.0000 + 1.0000i   -0.3333 + 1.3333i   -1.6667 + 1.6667i   -3.0000 + 2.0000i"
+        },
+        {
+            "description": "Staying on the GPU automatically",
+            "input": "a = gpuArray(0);\nb = gpuArray(2*pi);\ntheta = linspace(a, b, 1024);\nwave = sin(theta)",
+            "output": "% theta and wave remain on the GPU when an acceleration provider is active.\ndisp(gather(theta(1:5)))"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What is the default number of points?",
+            "answer": "If you omit the third argument, RunMat uses 100 points, matching MATLAB."
+        },
+        {
+            "question": "Does `linspace` include the end points?",
+            "answer": "Yes. The first element is exactly the start point `a` and the final element is exactly the end point `b`."
+        },
+        {
+            "question": "Can I request zero points?",
+            "answer": "Yes. `linspace(a, b, 0)` returns a `1×0` empty row vector."
+        },
+        {
+            "question": "Does the third argument need to be an integer?",
+            "answer": "Yes. Non-integer or negative counts raise an error, just like MATLAB."
+        },
+        {
+            "question": "Does `linspace` support complex inputs?",
+            "answer": "Yes. Real and imaginary components are interpolated independently. Mixed real and complex inputs return a complex row vector."
+        },
+        {
+            "question": "How accurate is the final point?",
+            "answer": "The implementation explicitly overwrites the final element with `b` to avoid floating-point drift, matching MATLAB behaviour."
+        },
+        {
+            "question": "Can I pass GPU scalars?",
+            "answer": "Yes. GPU endpoints are gathered once to compute the sequence. The result stays on the GPU as long as a provider is available and the endpoints are real."
+        },
+        {
+            "question": "What precision is used?",
+            "answer": "RunMat mirrors MATLAB and returns double-precision vectors. Providers may choose to specialise future hooks for other precisions."
+        },
+        {
+            "question": "How does `linspace` differ from the colon operator?",
+            "answer": "`linspace` lets you specify the number of points directly. The colon operator (`start:step:end`) fixes the spacing instead."
+        },
+        {
+            "question": "What happens when `a` equals `b`?",
+            "answer": "Every element equals `a` (and `b`). For example, `linspace(5, 5, 4)` returns `[5 5 5 5]`."
+        },
+        {
+            "question": "What does linspace do in MATLAB?",
+            "answer": "`linspace(a, b, n)` generates a row vector of `n` evenly spaced points between `a` and `b`, inclusive. The default value of `n` is 100."
+        },
+        {
+            "question": "How is linspace different from the colon operator?",
+            "answer": "The colon operator `a:step:b` specifies a step size and may not include the endpoint exactly. `linspace(a, b, n)` specifies the number of points and always includes both endpoints."
+        },
+        {
+            "question": "Can I use linspace to create logarithmically spaced points?",
+            "answer": "Not directly. Use `logspace(a, b, n)` for logarithmic spacing, which is equivalent to `10.^linspace(a, b, n)`."
+        },
+        {
+            "question": "Does linspace work with complex numbers?",
+            "answer": "Yes. `linspace(1+2i, 5+10i, 5)` linearly interpolates both the real and imaginary parts independently."
+        },
+        {
+            "question": "Can I use linspace with GPU arrays in RunMat?",
+            "answer": "Yes. Pass GPU scalars to `linspace` and the result will be a GPU-resident array, avoiding unnecessary host-device transfers."
+        }
+    ],
+    "links": [
+        {
+            "label": "zeros",
+            "url": "./zeros"
+        },
+        {
+            "label": "ones",
+            "url": "./ones"
+        },
+        {
+            "label": "rand",
+            "url": "./rand"
+        },
+        {
+            "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": "logspace",
+            "url": "./logspace"
+        },
+        {
+            "label": "magic",
+            "url": "./magic"
+        },
+        {
+            "label": "meshgrid",
+            "url": "./meshgrid"
+        },
+        {
+            "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/linspace.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/creation/linspace.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` yourself in RunMat. When either endpoint already resides on the GPU, RunMat keeps the generated sequence on the device to preserve residency for downstream operations. When the active provider implements the dedicated `linspace` hook (the WGPU backend does), the sequence is generated directly on-device. If no acceleration provider is registered, or if a provider lacks the hook, the runtime emits the values on the host and uploads them once, preserving correctness with a modest transfer.",
+    "gpu_behavior": [
+        "If either endpoint is already resident on the GPU, RunMat keeps the result on the device whenever the active acceleration provider supports uploading host buffers. Providers may additionally implement the optional `linspace` hook to generate the sequence entirely on device. Until then, RunMat generates the sequence on the host and performs a single upload so downstream kernels can consume the GPU data without extra gathers."
+    ],
+    "key": "linspace",
+    "slug": "linspace",
+    "categoryPath": [
+        "array",
+        "creation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=linspace.js.map

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

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

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

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

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

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