tack-core 0.7.0__tar.gz

tack_core-0.7.0/.gitignore

@@ -0,0 +1,25 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Generated images and example output
+results/
+*.npy
+*.vtu
+
+# Claude Code local config
+.claude/
+
+# Test artifacts
+.coverage
+.pytest_cache/
+
+# MkDocs build output
+site/

tack_core-0.7.0/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Kitware, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

tack_core-0.7.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.5
+Name: tack-core
+Version: 0.7.0
+Summary: Tack — GPU compute framework (core)
+Project-URL: Homepage, https://github.com/Kitware/tack
+Project-URL: Repository, https://github.com/Kitware/tack
+Project-URL: Documentation, https://kitware.github.io/tack/
+Project-URL: Issues, https://github.com/Kitware/tack/issues
+Author: Kitware, Inc.
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: compute,cuda,gpu,hip,jit,kernel,metal,visualization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.11
+Requires-Dist: numpy
+Provides-Extra: all
+Requires-Dist: cuda-python>=13.2.0; extra == 'all'
+Requires-Dist: hip-python>=7.0; (sys_platform == 'linux' and platform_machine == 'x86_64') and extra == 'all'
+Requires-Dist: llvmlite; extra == 'all'
+Requires-Dist: pyobjc-framework-metal; extra == 'all'
+Requires-Dist: pyobjc-framework-metalkit; extra == 'all'
+Provides-Extra: cpu
+Requires-Dist: llvmlite; extra == 'cpu'
+Provides-Extra: cuda
+Requires-Dist: cuda-python>=13.2.0; extra == 'cuda'
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Provides-Extra: hip
+Requires-Dist: hip-python>=7.0; (sys_platform == 'linux' and platform_machine == 'x86_64') and extra == 'hip'
+Provides-Extra: level-zero
+Provides-Extra: metal
+Requires-Dist: pyobjc-framework-metal; extra == 'metal'
+Requires-Dist: pyobjc-framework-metalkit; extra == 'metal'
+Provides-Extra: mpi
+Requires-Dist: mpi4py>=4.0; extra == 'mpi'
+Provides-Extra: warp
+Requires-Dist: warp-lang>=1.18; (sys_platform != 'darwin' or platform_machine == 'arm64') and extra == 'warp'
+Description-Content-Type: text/markdown
+
+# tack-core
+
+Kernels, arrays, types, IR, codegen and backends for [Tack](https://github.com/Kitware/tack) —
+a Python-first GPU compute framework.
+
+Write compute kernels as decorated Python functions; they are JIT-compiled at first call (and
+kept in a disk cache, so a later process loads them instead) and dispatched to whichever backend
+is active. The same kernel source runs on five backends, within
+each backend's capabilities (for example, Metal has no `f64` and the CPU has no workgroup
+primitives).
+
+```python
+import tack, numpy as np
+tack.set_default_device("cpu")          # or metal, cuda, hip, level_zero
+
+@tack.kernel
+def vector_add(x, y, out):
+    for i in range(x.shape[0]):   # outermost loop → thread parallelism
+        out[i] = x[i] + y[i]
+
+x = tack.empty((1024,))       # f32 unless a dtype is given
+y = tack.empty((1024,))
+out = tack.empty((1024,))
+tack.copyto(x, np.arange(1024, dtype=np.float32))
+tack.copyto(y, np.ones(1024, dtype=np.float32))
+
+vector_add(x, y, out)
+print(out.numpy())
+```
+
+## Install
+
+Pick the extras for your hardware. Keep `cpu` beside a GPU's extra: without it
+the CPU, the default device, cannot run kernels.
+
+```bash
+pip install "tack-core[cpu]"           # LLVM JIT via llvmlite
+pip install "tack-core[cpu,metal]"     # Apple silicon
+pip install "tack-core[cpu,cuda]"      # NVIDIA
+pip install "tack-core[cpu,hip]"       # AMD, with ROCm (hip-python: Linux x86-64)
+pip install "tack-core[cpu]"           # Intel: Level Zero is the system's runtime, no extra
+```
+
+Python 3.11 or newer. Tack is pure Python and compiles kernels when they are
+first called.
+
+## Backends
+
+| Backend | Codegen | Runtime compilation |
+|---------|---------|---------------------|
+| CPU | LLVM IR | llvmlite JIT |
+| Metal | MSL | Metal API |
+| CUDA | CUDA C | NVRTC → PTX |
+| HIP | HIP C | hipRTC |
+| Level Zero | OpenCL C | libocloc → SPIR-V |
+
+## Related packages
+
+- `tack-vis`: `tack.dataset`, with meshes, fields and visualization algorithms,
+  and the VTK and MFEM interop. It is not on PyPI; install it from the
+  repository, at the tag of the `tack-core` release you have, for example:
+
+  ```bash
+  pip install "tack-vis @ git+https://github.com/Kitware/tack@v0.7.0#subdirectory=packages/tack-vis"
+  ```
+
+Full documentation, examples and the kernel-language reference are in the
+[repository](https://github.com/Kitware/tack).
+
+BSD 3-Clause licensed.

tack_core-0.7.0/README.md

@@ -0,0 +1,70 @@
+# tack-core
+
+Kernels, arrays, types, IR, codegen and backends for [Tack](https://github.com/Kitware/tack) —
+a Python-first GPU compute framework.
+
+Write compute kernels as decorated Python functions; they are JIT-compiled at first call (and
+kept in a disk cache, so a later process loads them instead) and dispatched to whichever backend
+is active. The same kernel source runs on five backends, within
+each backend's capabilities (for example, Metal has no `f64` and the CPU has no workgroup
+primitives).
+
+```python
+import tack, numpy as np
+tack.set_default_device("cpu")          # or metal, cuda, hip, level_zero
+
+@tack.kernel
+def vector_add(x, y, out):
+    for i in range(x.shape[0]):   # outermost loop → thread parallelism
+        out[i] = x[i] + y[i]
+
+x = tack.empty((1024,))       # f32 unless a dtype is given
+y = tack.empty((1024,))
+out = tack.empty((1024,))
+tack.copyto(x, np.arange(1024, dtype=np.float32))
+tack.copyto(y, np.ones(1024, dtype=np.float32))
+
+vector_add(x, y, out)
+print(out.numpy())
+```
+
+## Install
+
+Pick the extras for your hardware. Keep `cpu` beside a GPU's extra: without it
+the CPU, the default device, cannot run kernels.
+
+```bash
+pip install "tack-core[cpu]"           # LLVM JIT via llvmlite
+pip install "tack-core[cpu,metal]"     # Apple silicon
+pip install "tack-core[cpu,cuda]"      # NVIDIA
+pip install "tack-core[cpu,hip]"       # AMD, with ROCm (hip-python: Linux x86-64)
+pip install "tack-core[cpu]"           # Intel: Level Zero is the system's runtime, no extra
+```
+
+Python 3.11 or newer. Tack is pure Python and compiles kernels when they are
+first called.
+
+## Backends
+
+| Backend | Codegen | Runtime compilation |
+|---------|---------|---------------------|
+| CPU | LLVM IR | llvmlite JIT |
+| Metal | MSL | Metal API |
+| CUDA | CUDA C | NVRTC → PTX |
+| HIP | HIP C | hipRTC |
+| Level Zero | OpenCL C | libocloc → SPIR-V |
+
+## Related packages
+
+- `tack-vis`: `tack.dataset`, with meshes, fields and visualization algorithms,
+  and the VTK and MFEM interop. It is not on PyPI; install it from the
+  repository, at the tag of the `tack-core` release you have, for example:
+
+  ```bash
+  pip install "tack-vis @ git+https://github.com/Kitware/tack@v0.7.0#subdirectory=packages/tack-vis"
+  ```
+
+Full documentation, examples and the kernel-language reference are in the
+[repository](https://github.com/Kitware/tack).
+
+BSD 3-Clause licensed.

tack_core-0.7.0/examples/01_hello_tack.py

@@ -0,0 +1,57 @@
+# SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""01 -- Hello Tack: your first kernel.
+
+This is the simplest possible Tack program.  It creates two arrays,
+adds them element-wise on the GPU (or CPU), and checks the result.
+
+Key concepts:
+  - tack.set_default_device() -- choose a device (cpu, metal, cuda, hip)
+  - tack.empty()   -- allocate a device array
+  - @tack.kernel   -- mark a function for GPU compilation
+  - from_numpy / to_numpy -- move data between host and device
+
+Usage:
+  uv run python examples/01_hello_tack.py
+"""
+
+import argparse
+
+import numpy as np
+
+import tack
+
+_parser = argparse.ArgumentParser()
+_parser.add_argument('--arch', default='cpu', choices=['cpu', 'metal', 'cuda', 'hip', 'level_zero'])
+_arch = _parser.parse_args().arch
+tack.set_default_device(_arch)
+
+# Allocate 1-D arrays (device arrays)
+n = 10
+x = tack.empty((n,))
+y = tack.empty((n,))
+out = tack.empty((n,))
+
+# Upload data from numpy
+tack.copyto(x, np.arange(n, dtype=np.float32))        # [0, 1, 2, ..., 9]
+tack.copyto(y, np.ones(n, dtype=np.float32) * 10.0)   # [10, 10, ..., 10]
+
+
+@tack.kernel
+def add(x, y, out):
+    # The top-level for-range is parallelized across threads
+    for i in range(x.shape[0]):
+        out[i] = x[i] + y[i]
+
+
+# Run the kernel
+add(x, y, out)
+
+# Download result to numpy and print
+result = out.numpy()
+print("x  =", x.numpy())
+print("y  =", y.numpy())
+print("out=", result)
+assert np.allclose(result, np.arange(n) + 10.0)
+print("\nAll correct!")

tack_core-0.7.0/examples/02_math_builtins.py

@@ -0,0 +1,54 @@
+# SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""02 -- Math builtins available inside kernels.
+
+Tack kernels have access to standard math functions without any imports.
+They compile to hardware intrinsics (LLVM on CPU, device functions on GPU).
+
+Available: sqrt, sin, cos, tan, asin, acos, atan, atan2,
+           exp, exp2, log, log2, log10, floor, ceil,
+           abs, min, max, pow
+
+Usage:
+  uv run python examples/02_math_builtins.py
+"""
+
+import argparse
+
+import numpy as np
+
+import tack
+
+_parser = argparse.ArgumentParser()
+_parser.add_argument('--arch', default='cpu', choices=['cpu', 'metal', 'cuda', 'hip', 'level_zero'])
+_arch = _parser.parse_args().arch
+tack.set_default_device(_arch)
+
+n = 256
+x = tack.empty((n,))
+out_sqrt = tack.empty((n,))
+out_sin = tack.empty((n,))
+out_combined = tack.empty((n,))
+
+tack.copyto(x, np.linspace(0.1, 10.0, n, dtype=np.float32))
+
+
+@tack.kernel
+def apply_math(x, out_sqrt, out_sin, out_combined):
+    for i in range(x.shape[0]):
+        out_sqrt[i] = sqrt(x[i])
+        out_sin[i] = sin(x[i])
+        # Mix several builtins in one expression
+        out_combined[i] = exp(-x[i]) * cos(x[i] * 3.14159) + abs(log(x[i]))
+
+
+apply_math(x, out_sqrt, out_sin, out_combined)
+
+np_x = x.numpy()
+print("sqrt  error:", np.max(np.abs(out_sqrt.numpy() - np.sqrt(np_x))))
+print("sin   error:", np.max(np.abs(out_sin.numpy() - np.sin(np_x))))
+
+expected = np.exp(-np_x) * np.cos(np_x * 3.14159) + np.abs(np.log(np_x))
+print("combo error:", np.max(np.abs(out_combined.numpy() - expected)))
+print("\nAll within float32 tolerance!")

tack_core-0.7.0/examples/03_scalar_args.py

@@ -0,0 +1,56 @@
+# SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""03 -- Scalar arguments: pass Python numbers directly to kernels.
+
+Kernels can accept plain Python int/float values alongside arrays.
+This is useful for passing constants like time steps, coefficients,
+or array sizes without creating an array.
+
+Usage:
+  uv run python examples/03_scalar_args.py
+"""
+
+import argparse
+
+import numpy as np
+
+import tack
+
+_parser = argparse.ArgumentParser()
+_parser.add_argument('--arch', default='cpu', choices=['cpu', 'metal', 'cuda', 'hip', 'level_zero'])
+_arch = _parser.parse_args().arch
+tack.set_default_device(_arch)
+
+n = 1000
+x = tack.empty((n,))
+y = tack.empty((n,))
+out = tack.empty((n,))
+
+tack.copyto(x, np.arange(n, dtype=np.float32))
+tack.copyto(y, np.ones(n, dtype=np.float32) * 3.0)
+
+
+@tack.kernel
+def saxpy(x, y, out, alpha, n):
+    """out = alpha * x + y  (SAXPY: Single-precision A*X Plus Y)"""
+    for i in range(n):
+        out[i] = alpha * x[i] + y[i]
+
+
+# Pass scalar values directly -- no need to wrap in arrays
+alpha = 2.5
+saxpy(x, y, out, alpha, n)
+
+result = out.numpy()
+expected = alpha * np.arange(n, dtype=np.float32) + 3.0
+assert np.allclose(result, expected)
+print(f"SAXPY with alpha={alpha}: first 5 results = {result[:5]}")
+
+# Call again with a different alpha -- same compiled kernel is reused
+saxpy(x, y, out, -1.0, n)
+result2 = out.numpy()
+expected2 = -1.0 * np.arange(n, dtype=np.float32) + 3.0
+assert np.allclose(result2, expected2)
+print(f"SAXPY with alpha=-1.0: first 5 results = {result2[:5]}")
+print("\nScalar arguments work correctly!")

tack_core-0.7.0/examples/04_control_flow.py

@@ -0,0 +1,102 @@
+# SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""04 -- Control flow: if/else, while loops, break, ternary expressions.
+
+Tack kernels support standard Python control flow.  The top-level for-range
+is parallelized; everything inside runs per-thread.
+
+Usage:
+  uv run python examples/04_control_flow.py
+"""
+
+import argparse
+
+import numpy as np
+
+import tack
+
+_parser = argparse.ArgumentParser()
+_parser.add_argument('--arch', default='cpu', choices=['cpu', 'metal', 'cuda', 'hip', 'level_zero'])
+_arch = _parser.parse_args().arch
+tack.set_default_device(_arch)
+
+n = 256
+x = tack.empty((n,))
+out = tack.empty((n,))
+
+data = np.arange(n, dtype=np.float32) - 128.0  # [-128, ..., 127]
+tack.copyto(x, data)
+
+# --- Example 1: if/else (ReLU activation) ---
+
+@tack.kernel
+def relu(x, out):
+    for i in range(x.shape[0]):
+        if x[i] > 0.0:
+            out[i] = x[i]
+        else:
+            out[i] = 0.0
+
+relu(x, out)
+assert np.allclose(out.numpy(), np.maximum(data, 0.0))
+print("1. ReLU (if/else): OK")
+
+# --- Example 2: while loop with early exit ---
+
+@tack.kernel
+def collatz_steps(x, out):
+    """Count Collatz steps until reaching 1."""
+    for i in range(x.shape[0]):
+        val = abs(x[i]) + 1.0  # ensure positive, > 0
+        steps = 0.0
+        while val > 1.0:
+            if val > 1000.0:
+                break  # safety limit
+            n_int = int(val)
+            if n_int % 2 == 0:
+                val = val / 2.0
+            else:
+                val = val * 3.0 + 1.0
+            steps = steps + 1.0
+        out[i] = steps
+
+collatz_steps(x, out)
+print("2. Collatz steps (while + break): OK, first 5 steps =", out.numpy()[:5])
+
+# --- Example 3: ternary expression ---
+
+@tack.kernel
+def clamp(x, out):
+    """Clamp values to [-50, 50] using ternary expressions."""
+    for i in range(x.shape[0]):
+        v = x[i]
+        v = v if v > -50.0 else -50.0
+        v = v if v < 50.0 else 50.0
+        out[i] = v
+
+clamp(x, out)
+expected = np.clip(data, -50.0, 50.0)
+assert np.allclose(out.numpy(), expected)
+print("3. Clamp (ternary): OK")
+
+# --- Example 4: nested loops ---
+
+n2 = 16
+mat = tack.empty((n2 * n2,))
+
+@tack.kernel
+def fill_checkerboard(mat):
+    for i in range(16):
+        for j in range(16):
+            if (i + j) % 2 == 0:
+                mat[i * 16 + j] = 1.0
+            else:
+                mat[i * 16 + j] = 0.0
+
+fill_checkerboard(mat)
+board = mat.numpy().reshape(16, 16)
+print("4. Checkerboard (nested loops): OK")
+print("   Top-left 4x4:")
+for row in board[:4]:
+    print("  ", " ".join(f"{v:.0f}" for v in row[:4]))

tack_core-0.7.0/examples/05_ndindex.py

@@ -0,0 +1,78 @@
+# SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""05 -- Multi-dimensional parallel iteration with tack.ndindex.
+
+Instead of computing linear indices manually, use tack.ndindex(w, h) to
+iterate over a 2D grid in parallel.  Each (i, j) pair maps to a separate
+GPU thread.
+
+Usage:
+  uv run python examples/05_ndindex.py
+"""
+
+import argparse
+
+import numpy as np
+
+import tack
+
+_parser = argparse.ArgumentParser()
+_parser.add_argument('--arch', default='cpu', choices=['cpu', 'metal', 'cuda', 'hip', 'level_zero'])
+_arch = _parser.parse_args().arch
+tack.set_default_device(_arch)
+
+width, height = 64, 64
+pixels = tack.empty((width, height))
+
+
+@tack.kernel
+def distance_array(pixels):
+    """Compute distance from center for each pixel."""
+    for i, j in tack.ndindex(64, 64):
+        dx = float(i) - 32.0
+        dy = float(j) - 32.0
+        pixels[i, j] = sqrt(dx * dx + dy * dy)
+
+
+distance_array(pixels)
+
+result = pixels.numpy().reshape(64, 64)
+# Check center is ~0, corners are ~45
+assert result[32, 32] == 0.0
+corner_dist = result[0, 0]
+assert abs(corner_dist - np.sqrt(32**2 + 32**2)) < 0.01
+print(f"Center distance: {result[32, 32]:.2f} (expected 0)")
+print(f"Corner distance: {corner_dist:.2f} (expected {np.sqrt(32**2+32**2):.2f})")
+
+# --- Example 2: 2D Gaussian blur (3x3 kernel) ---
+
+src = tack.empty((64, 64))
+dst = tack.empty((64, 64))
+
+# Create a simple image: bright spot at center
+img = np.zeros((64, 64), dtype=np.float32)
+img[32, 32] = 100.0
+tack.copyto(src, img)
+
+
+@tack.kernel
+def blur_3x3(src, dst):
+    """Simple 3x3 box blur, skipping borders."""
+    for i, j in tack.ndindex(64, 64):
+        if i > 0:
+            if i < 63:
+                if j > 0:
+                    if j < 63:
+                        s = 0.0
+                        for di in range(-1, 2):
+                            for dj in range(-1, 2):
+                                s = s + src[i + di, j + dj]
+                        dst[i, j] = s / 9.0
+
+
+blur_3x3(src, dst)
+blurred = dst.numpy().reshape(64, 64)
+print(f"\nBlur: center pixel {blurred[32,32]:.2f} (was 100.00)")
+print(f"Blur: neighbor    {blurred[32,33]:.2f} (was 0.00)")
+print("2D ndindex + stencil: OK")

tack_core-0.7.0/examples/06_device_functions.py

@@ -0,0 +1,78 @@
+# SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""06 -- Device functions with @tack.func.
+
+Use @tack.func to define helper functions that are inlined into kernels
+at compile time.  This keeps kernels clean and lets you reuse logic.
+
+Usage:
+  uv run python examples/06_device_functions.py
+"""
+
+import argparse
+
+import numpy as np
+
+import tack
+
+_parser = argparse.ArgumentParser()
+_parser.add_argument('--arch', default='cpu', choices=['cpu', 'metal', 'cuda', 'hip', 'level_zero'])
+_arch = _parser.parse_args().arch
+tack.set_default_device(_arch)
+
+
+# --- Device function: inlined wherever called ---
+
+@tack.func
+def lerp(a, b, t):
+    """Linear interpolation: a*(1-t) + b*t"""
+    return a + t * (b - a)
+
+
+@tack.func
+def smoothstep(edge0, edge1, x):
+    """Hermite smoothstep interpolation."""
+    t = (x - edge0) / (edge1 - edge0)
+    t = max(0.0, min(1.0, t))
+    return t * t * (3.0 - 2.0 * t)
+
+
+@tack.func
+def remap(value, in_lo, in_hi, out_lo, out_hi):
+    """Remap a value from one range to another."""
+    t = (value - in_lo) / (in_hi - in_lo)
+    return lerp(out_lo, out_hi, t)  # device functions can call each other
+
+
+# --- Kernel using device functions ---
+
+n = 100
+x = tack.empty((n,))
+out_lerp = tack.empty((n,))
+out_smooth = tack.empty((n,))
+out_remap = tack.empty((n,))
+
+tack.copyto(x, np.linspace(0.0, 1.0, n, dtype=np.float32))
+
+
+@tack.kernel
+def apply_all(x, out_lerp, out_smooth, out_remap):
+    for i in range(x.shape[0]):
+        t = x[i]
+        out_lerp[i] = lerp(0.0, 100.0, t)
+        out_smooth[i] = smoothstep(0.2, 0.8, t)
+        out_remap[i] = remap(t, 0.0, 1.0, -10.0, 10.0)
+
+
+apply_all(x, out_lerp, out_smooth, out_remap)
+
+print("lerp(0,100,t):  ", out_lerp.numpy()[[0, 25, 50, 75, 99]])
+print("smoothstep:     ", out_smooth.numpy()[[0, 25, 50, 75, 99]])
+print("remap(0,1,-10,10):", out_remap.numpy()[[0, 25, 50, 75, 99]])
+
+# Verify lerp
+assert np.allclose(out_lerp.numpy(), np.linspace(0, 100, n))
+# Verify remap
+assert np.allclose(out_remap.numpy(), np.linspace(-10, 10, n))
+print("\nDevice functions: OK")