runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/hypot.js

@@ -0,0 +1,245 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "hypot",
+    "category": "math/elementwise",
+    "keywords": [
+        "hypot",
+        "euclidean norm",
+        "distance",
+        "gpu",
+        "elementwise"
+    ],
+    "summary": "Element-wise Euclidean norm sqrt(x.^2 + y.^2) with MATLAB-compatible broadcasting.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/hypot.html"
+    ],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Runs entirely on the GPU when the provider implements elem_hypot; otherwise the runtime gathers inputs and falls back to the CPU path."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::elementwise::hypot::tests",
+        "integration": "builtins::math::elementwise::hypot::tests::hypot_gpu_provider_roundtrip",
+        "gpu": "builtins::math::elementwise::hypot::tests::hypot_wgpu_matches_cpu_elementwise"
+    },
+    "description": "`z = hypot(x, y)` computes the element-wise Euclidean norm `sqrt(|x|.^2 + |y|.^2)` with overflow-resistant arithmetic. It accepts scalars, vectors, matrices, N-D tensors, and complex inputs, following MATLAB's implicit expansion (broadcasting) rules.",
+    "behaviors": [
+        "Real inputs return non-negative doubles even when the operands are negative.",
+        "Complex arguments are converted to their magnitudes before forming `sqrt(|x|.^2 + |y|.^2)`, matching MATLAB's definition since R2020b.",
+        "Scalars broadcast across the other operand when shapes are compatible; otherwise an error is raised.",
+        "Empty inputs propagate emptiness according to MATLAB's size rules.",
+        "`Inf` operands return `Inf`; `NaN` operands propagate `NaN`."
+    ],
+    "examples": [
+        {
+            "description": "Computing the hypotenuse of two scalars",
+            "input": "result = hypot(3, 4)",
+            "output": "result = 5"
+        },
+        {
+            "description": "Using `hypot` with vectors and implicit expansion",
+            "input": "x = [-3, 0, 4];\ny = 4;\nnorms = hypot(x, y)",
+            "output": "norms = [5 4 5]"
+        },
+        {
+            "description": "Calculating per-element distances between two matrices",
+            "input": "X = [1 2; 3 4];\nY = [0 1; 1 0];\ndist = hypot(X, Y)",
+            "output": "dist = [1.0000 2.2361; 3.1623 4.0000]"
+        },
+        {
+            "description": "Working with complex numbers",
+            "input": "a = [1+2i, 3-4i];\nb = [2-1i, -1+1i];\nmag = hypot(a, b)",
+            "output": "mag = [3.1623 5.1962]"
+        },
+        {
+            "description": "Applying `hypot` to character data",
+            "input": "codes = hypot('A', zeros(1, 1))",
+            "output": "codes = 65.0000"
+        },
+        {
+            "description": "Executing `hypot` on GPU arrays",
+            "input": "Gx = gpuArray([3 4; 5 12]);\nGy = gpuArray([4 3; 12 5]);\ndistance_gpu = hypot(Gx, Gy);\ndistance = gather(distance_gpu)",
+            "output": "distance = [5 5; 13 13]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `hypot` overflow for large inputs?",
+            "answer": "No. Like MATLAB, RunMat uses a stable algorithm that scales the operands to avoid overflow and underflow. Very large inputs return finite results when mathematically possible."
+        },
+        {
+            "question": "What happens when the inputs are negative?",
+            "answer": "`hypot` always returns a non-negative result because it squares the magnitudes first. Signs on the inputs only matter when NaN or Inf is involved."
+        },
+        {
+            "question": "Can I mix real and complex inputs?",
+            "answer": "Yes. Complex inputs are converted to magnitudes before forming the norm, so you can freely combine real, complex, and logical data."
+        },
+        {
+            "question": "Does `hypot` accept logical or character arrays?",
+            "answer": "Yes. Logical values map to `0` and `1`, while character arrays use their Unicode code points (as doubles), matching MATLAB semantics."
+        },
+        {
+            "question": "How does broadcasting work?",
+            "answer": "The function applies MATLAB's implicit expansion: singleton dimensions expand to match the other operand. If a non-singleton dimension differs, RunMat raises a dimension mismatch error."
+        },
+        {
+            "question": "Are GPU results identical to CPU results?",
+            "answer": "For double precision providers the results match bit-for-bit. Single precision providers (e.g., `wgpu` in F32 mode) may differ by typical floating-point rounding."
+        },
+        {
+            "question": "What if only one operand lives on the GPU?",
+            "answer": "The runtime gathers the GPU operand, computes the norm on the host, and continues execution. Future providers may implement scalar expansion directly on the device."
+        },
+        {
+            "question": "Does `hypot` allocate a new array?",
+            "answer": "Yes. The builtin returns a fresh tensor. Fusion may elide intermediate buffers when the expression participates in a larger GPU kernel."
+        },
+        {
+            "question": "How can I compute the magnitude of a vector of components?",
+            "answer": "Use `hypot` repeatedly: `hypot(x, hypot(y, z))` computes the Euclidean norm of `(x, y, z)` element-wise without manual squaring."
+        }
+    ],
+    "links": [
+        {
+            "label": "sqrt",
+            "url": "./sqrt"
+        },
+        {
+            "label": "abs",
+            "url": "./abs"
+        },
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "angle",
+            "url": "./angle"
+        },
+        {
+            "label": "conj",
+            "url": "./conj"
+        },
+        {
+            "label": "double",
+            "url": "./double"
+        },
+        {
+            "label": "exp",
+            "url": "./exp"
+        },
+        {
+            "label": "expm1",
+            "url": "./expm1"
+        },
+        {
+            "label": "factorial",
+            "url": "./factorial"
+        },
+        {
+            "label": "gamma",
+            "url": "./gamma"
+        },
+        {
+            "label": "imag",
+            "url": "./imag"
+        },
+        {
+            "label": "ldivide",
+            "url": "./ldivide"
+        },
+        {
+            "label": "log",
+            "url": "./log"
+        },
+        {
+            "label": "log10",
+            "url": "./log10"
+        },
+        {
+            "label": "log1p",
+            "url": "./log1p"
+        },
+        {
+            "label": "log2",
+            "url": "./log2"
+        },
+        {
+            "label": "minus",
+            "url": "./minus"
+        },
+        {
+            "label": "plus",
+            "url": "./plus"
+        },
+        {
+            "label": "pow2",
+            "url": "./pow2"
+        },
+        {
+            "label": "power",
+            "url": "./power"
+        },
+        {
+            "label": "rdivide",
+            "url": "./rdivide"
+        },
+        {
+            "label": "real",
+            "url": "./real"
+        },
+        {
+            "label": "sign",
+            "url": "./sign"
+        },
+        {
+            "label": "single",
+            "url": "./single"
+        },
+        {
+            "label": "times",
+            "url": "./times"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/elementwise/hypot.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/hypot.rs"
+    },
+    "gpu_residency": "Manual `gpuArray` calls are typically unnecessary. RunMat's planner keeps tensors on the GPU when profitable and automatically gathers data when the active provider lacks `elem_hypot`. You can still force residency with explicit `gpuArray`/`gather` to mirror MATLAB workflows or when interoperating with custom kernels.",
+    "gpu_behavior": [
+        "**Hook available and shapes match:** the Euclidean norm executes in a single fused GPU kernel.",
+        "**Hook missing or implicit expansion required:** RunMat gathers the data to the host, computes the MATLAB-compatible result, and reuses the host tensor downstream.",
+        "**Fusion-enabled expressions:** the fusion planner can emit a WGSL `hypot(a, b)` node so long as the active provider marks the group as supported; otherwise the execution seamlessly falls back to the host path.\n\nProviders can implement `elem_hypot` by emitting a single WGSL/compute shader that calls `hypot(a, b)`; the included WGPU backend demonstrates this pattern."
+    ],
+    "key": "hypot",
+    "slug": "hypot",
+    "categoryPath": [
+        "math",
+        "elementwise"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=hypot.js.map

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

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

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

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

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

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

package/dist/generated/builtins/ifft.js

@@ -0,0 +1,147 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "ifft",
+    "category": "math/fft",
+    "keywords": [
+        "ifft",
+        "inverse fft",
+        "inverse fourier transform",
+        "symmetric",
+        "gpu"
+    ],
+    "summary": "Compute the inverse discrete Fourier transform (IDFT) of vectors, matrices, or N-D tensors.",
+    "references": [
+        "title: \"MATLAB ifft documentation\""
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Falls back to host execution when the acceleration provider does not expose an inverse FFT hook; even with a hook, the result is downloaded immediately to return a MATLAB-compatible host array."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::fft::ifft::tests",
+        "integration": "builtins::math::fft::ifft::tests::ifft_gpu_roundtrip_matches_cpu"
+    },
+    "description": "`ifft(X)` performs the inverse discrete Fourier transform (IDFT) of the data in `X`. For vectors, the result is a time-domain sequence whose FFT equals the original input. For matrices and higher-rank tensors, the transform is applied along the first non-singleton dimension unless a different dimension is specified.",
+    "behaviors": [
+        "`ifft(X)` transforms along the first dimension whose size is greater than 1.",
+        "`ifft(X, N)` zero-pads or truncates `X` to length `N` before applying the transform.",
+        "`ifft(X, N, DIM)` applies the transform along dimension `DIM`.",
+        "`ifft(X, [], DIM)` keeps the existing length and transforms along dimension `DIM`.",
+        "`ifft(..., 'symmetric')` forces the output to be real-valued, mirroring MATLAB's handling of conjugate-symmetric spectra.",
+        "`ifft(..., 'nonsymmetric')` keeps the default complex result; it is equivalent to omitting the symmetry flag but is accepted for MATLAB compatibility.",
+        "Empty inputs and dimensions larger than the rank of `X` mirror MATLAB behaviour."
+    ],
+    "examples": [
+        {
+            "description": "Reconstructing a time-domain signal from FFT bins",
+            "input": "Y = [10  -2+2i  -2  -2-2i];\nx = ifft(Y)",
+            "output": "x =\n  Columns 1 through 4\n       1     2     3     4"
+        },
+        {
+            "description": "Computing `ifft` along a specific dimension",
+            "input": "F = [10  14  18;\n     -3+3i  -3+3i  -3+3i];\nX = ifft(F, [], 1)"
+        },
+        {
+            "description": "Zero-padding the inverse transform",
+            "input": "F = [4 0 0 0];\nx = ifft(F, 8)"
+        },
+        {
+            "description": "Enforcing a real result with `'symmetric'`",
+            "input": "F = fft([1 2 3 4]);\nx = ifft(F, 'symmetric')"
+        },
+        {
+            "description": "Running `ifft` on `gpuArray` inputs",
+            "input": "G = gpuArray(fft([1 0 0 0]));\nX = ifft(G);\nresult = gather(X)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `ifft` always return complex values?",
+            "answer": "By default, yes. The `'symmetric'` flag converts the result to a real array when the spectrum is conjugate-symmetric. You can also pass `'nonsymmetric'` to state this default explicitly while keeping the complex result."
+        },
+        {
+            "question": "How does `ifft` scale the result?",
+            "answer": "RunMat divides by the transform length so that `ifft(fft(x))` reproduces `x`, matching MATLAB."
+        },
+        {
+            "question": "Can I omit the length but specify a dimension?",
+            "answer": "Yes. Use an empty array for the length: `ifft(X, [], DIM)`."
+        },
+        {
+            "question": "What happens if I request a zero length?",
+            "answer": "You receive an empty array along the selected dimension, mirroring MATLAB behaviour."
+        },
+        {
+            "question": "Does `'symmetric'` validate conjugate symmetry?",
+            "answer": "No. Like MATLAB, RunMat assumes the spectrum is conjugate-symmetric and simply discards imaginary components."
+        },
+        {
+            "question": "Will RunMat run the inverse FFT on the GPU automatically?",
+            "answer": "Only when the provider exposes an inverse FFT kernel (`ifft_dim`). Otherwise, the runtime gathers to the host transparently."
+        },
+        {
+            "question": "How do I perform multi-dimensional inverse transforms?",
+            "answer": "Apply `ifft` sequentially along each dimension (e.g., `ifft(ifft(X, [], 1), [], 2)`)."
+        }
+    ],
+    "links": [
+        {
+            "label": "fft",
+            "url": "./fft"
+        },
+        {
+            "label": "fftshift",
+            "url": "./fftshift"
+        },
+        {
+            "label": "ifftshift",
+            "url": "./ifftshift"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "fft2",
+            "url": "./fft2"
+        },
+        {
+            "label": "ifft2",
+            "url": "./ifft2"
+        }
+    ],
+    "source": {
+        "label": "Open a ticket",
+        "url": "https://github.com/runmat-org/runmat/issues/new/choose"
+    },
+    "gpu_residency": "RunMat's auto-offload system keeps tensors on the GPU when profitable, so explicit `gpuArray` calls are rarely required. They remain available to mirror MATLAB workflows. When the provider lacks an inverse FFT hook, RunMat automatically gathers once, evaluates the transform on the host, and returns the result, so manual residency management is unnecessary.",
+    "gpu_behavior": [
+        "RunMat keeps `gpuArray` inputs on the device long enough to query the active acceleration provider for the `ifft_dim` hook. When the hook is present, the inverse transform executes on the device, after which RunMat immediately downloads the result to return the standard MATLAB host types. If the provider lacks that hook—or if the requested length is zero—the runtime gathers the data once, evaluates the inverse transform on the CPU via `rustfft`, and returns a MATLAB-compatible result."
+    ],
+    "key": "ifft",
+    "slug": "ifft",
+    "categoryPath": [
+        "math",
+        "fft"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=ifft.js.map

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

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

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

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

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

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

package/dist/generated/builtins/ifft2.js

@@ -0,0 +1,159 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "ifft2",
+    "category": "math/fft",
+    "keywords": [
+        "ifft2",
+        "inverse 2d fft",
+        "image reconstruction",
+        "symmetric",
+        "gpu"
+    ],
+    "summary": "Compute the two-dimensional inverse discrete Fourier transform (IDFT) of numeric or complex data.",
+    "references": [
+        "title: \"MATLAB ifft2 documentation\""
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Runs two provider-backed ifft_dim passes when available; otherwise RunMat gathers to the host and performs the transform with rustfft."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::fft::ifft2::tests",
+        "integration": "builtins::math::fft::ifft2::tests::ifft2_gpu_roundtrip_matches_cpu"
+    },
+    "description": "`ifft2(X)` computes the two-dimensional inverse discrete Fourier transform (IDFT) of `X`. It undoes the effect of `fft2` by applying `ifft` along the first dimension and then along the second dimension, preserving MATLAB’s column-major semantics.",
+    "behaviors": [
+        "`ifft2(X)` transforms along the first two dimensions whose sizes exceed one.",
+        "`ifft2(X, M, N)` zero-pads or truncates the spectrum to `M` rows and `N` columns before the inverse.",
+        "`ifft2(X, SIZE)` accepts a scalar or two-element vector describing the transform lengths.",
+        "`ifft2(..., 'symmetric')` discards tiny imaginary parts and returns a real matrix when the spectrum is conjugate-symmetric. `'nonsymmetric'` keeps the complex result.",
+        "Higher-dimensional inputs are processed slice-by-slice across trailing dimensions.",
+        "Empty sizes and zero padding mirror MATLAB behaviour, producing empty outputs when any requested length is zero."
+    ],
+    "examples": [
+        {
+            "description": "Reconstructing an image patch from its 2-D spectrum",
+            "input": "F = [10  -2  0  -2;\n     -4   0  0   0];\nx = ifft2(F)",
+            "output": "x =\n    1.0000    2.0000\n    3.0000    4.0000"
+        },
+        {
+            "description": "Zero-padding before the inverse transform",
+            "input": "F = fft2([1 0; 0 1], 4, 4);\nspatial = ifft2(F, 4, 4)"
+        },
+        {
+            "description": "Supplying transform lengths with a size vector",
+            "input": "Y = fft2(rand(3,4));\nX = ifft2(Y, [5 2]);   % pad rows to 5, truncate columns to 2"
+        },
+        {
+            "description": "Forcing a real-valued result with `'symmetric'`",
+            "input": "F = fft2([1 2; 3 4]);\nrealImage = ifft2(F, 'symmetric')"
+        },
+        {
+            "description": "Running `ifft2` on `gpuArray` inputs",
+            "input": "G = gpuArray(fft2(peaks(64)));\nspatial = ifft2(G);\nresult = gather(spatial)"
+        },
+        {
+            "description": "Recovering each slice of a volume",
+            "input": "spectra = fft2(rand(16, 16, 10));\nvolume = ifft2(spectra)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Is `ifft2(X)` equivalent to `ifft(ifft(X, [], 1), [], 2)`?",
+            "answer": "Yes. RunMat literally performs two sequential 1-D inverse transforms so the behaviour matches MATLAB exactly."
+        },
+        {
+            "question": "How do zero-length sizes behave?",
+            "answer": "Passing `0` for either transform length produces an output with zero elements along that dimension, just like MATLAB."
+        },
+        {
+            "question": "Can I mix `[]` with explicit sizes (e.g., `ifft2(X, [], 64)`)?",
+            "answer": "Yes. `[]` leaves that dimension unchanged while the other argument controls padding or truncation."
+        },
+        {
+            "question": "What does the `'symmetric'` flag do?",
+            "answer": "It tells RunMat to coerce the result to real values, assuming the spectrum is conjugate-symmetric. Imaginary parts are dropped."
+        },
+        {
+            "question": "What happens when the input is real-valued?",
+            "answer": "RunMat promotes the data to complex with zero imaginary parts before applying the inverse. The output can still be coerced to real with `'symmetric'`."
+        },
+        {
+            "question": "Will `ifft2` run on the GPU automatically?",
+            "answer": "Yes when the active provider exposes `ifft_dim`. Otherwise the runtime gathers to the host and evaluates the inverse using `rustfft`."
+        },
+        {
+            "question": "Does `ifft2` normalise the result?",
+            "answer": "Yes. The builtin divides by the product of the transform lengths so that `ifft2(fft2(X))` reproduces `X`."
+        },
+        {
+            "question": "Can I pass `gpuArray` size vectors or symmetry flags?",
+            "answer": "No. Length arguments must be host scalars or vectors, and the symmetry flag must be a host string, mirroring MATLAB’s restrictions."
+        },
+        {
+            "question": "How are higher-dimensional arrays handled?",
+            "answer": "Transformations are applied to every 2-D slice defined by the first two dimensions; trailing dimensions are preserved unchanged."
+        },
+        {
+            "question": "Does `'nonsymmetric'` change the result?",
+            "answer": "It simply states the default behaviour (return complex outputs) but is accepted for MATLAB compatibility."
+        }
+    ],
+    "links": [
+        {
+            "label": "fft2",
+            "url": "./fft2"
+        },
+        {
+            "label": "ifft",
+            "url": "./ifft"
+        },
+        {
+            "label": "fft",
+            "url": "./fft"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "fftshift",
+            "url": "./fftshift"
+        },
+        {
+            "label": "ifftshift",
+            "url": "./ifftshift"
+        }
+    ],
+    "source": {
+        "label": "Open a ticket",
+        "url": "https://github.com/runmat-org/runmat/issues/new/choose"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` manually. RunMat’s native acceleration layer keeps intermediate tensors on the GPU whenever the provider implements `ifft_dim`. If the provider lacks that hook (or detects an unsupported length), RunMat gathers the input once, executes the inverse transform on the CPU with `rustfft`, and returns a MATLAB-compatible result automatically.",
+    "key": "ifft2",
+    "slug": "ifft2",
+    "categoryPath": [
+        "math",
+        "fft"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=ifft2.js.map

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

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

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

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

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

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