warp-lang 1.7.2rc1__py3-none-manylinux_2_34_aarch64.whl → 1.8.1__py3-none-manylinux_2_34_aarch64.whl

warp/__init__.pyi

@@ -1 +1,3489 @@
-from .stubs import *
+# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Autogenerated file, do not edit, this file provides stubs for builtins autocomplete in VSCode, PyCharm, etc
+
+from typing import Any
+from typing import Tuple
+from typing import Callable
+from typing import TypeVar
+from typing import Generic
+from typing import overload as over
+
+Length = TypeVar("Length", bound=int)
+Rows = TypeVar("Rows", bound=int)
+Cols = TypeVar("Cols", bound=int)
+DType = TypeVar("DType")
+Shape = TypeVar("Shape")
+Vector = Generic[Length, Scalar]
+Matrix = Generic[Rows, Cols, Scalar]
+Quaternion = Generic[Float]
+Transformation = Generic[Float]
+Array = Generic[DType]
+FabricArray = Generic[DType]
+IndexedFabricArray = Generic[DType]
+Tile = Generic[DType, Shape]
+
+from warp.types import array, array1d, array2d, array3d, array4d, constant, from_ptr
+from warp.types import indexedarray, indexedarray1d, indexedarray2d, indexedarray3d, indexedarray4d
+from warp.fabric import fabricarray, fabricarrayarray, indexedfabricarray, indexedfabricarrayarray
+from warp.types import tile
+
+from warp.types import bool, int8, uint8, int16, uint16, int32, uint32, int64, uint64, float16, float32, float64
+from warp.types import vec2, vec2b, vec2ub, vec2s, vec2us, vec2i, vec2ui, vec2l, vec2ul, vec2h, vec2f, vec2d
+from warp.types import vec3, vec3b, vec3ub, vec3s, vec3us, vec3i, vec3ui, vec3l, vec3ul, vec3h, vec3f, vec3d
+from warp.types import vec4, vec4b, vec4ub, vec4s, vec4us, vec4i, vec4ui, vec4l, vec4ul, vec4h, vec4f, vec4d
+from warp.types import mat22, mat22h, mat22f, mat22d
+from warp.types import mat33, mat33h, mat33f, mat33d
+from warp.types import mat44, mat44h, mat44f, mat44d
+from warp.types import quat, quath, quatf, quatd
+from warp.types import transform, transformh, transformf, transformd
+from warp.types import spatial_vector, spatial_vectorh, spatial_vectorf, spatial_vectord
+from warp.types import spatial_matrix, spatial_matrixh, spatial_matrixf, spatial_matrixd
+
+from warp.types import Int, Float, Scalar
+
+from warp.types import Bvh, Mesh, HashGrid, Volume, MarchingCubes
+from warp.types import BvhQuery, HashGridQuery, MeshQueryAABB, MeshQueryPoint, MeshQueryRay
+
+from warp.types import matmul, adj_matmul, batched_matmul, adj_batched_matmul
+
+from warp.types import vector as vec
+from warp.types import matrix as mat
+
+from warp.types import dtype_from_numpy, dtype_to_numpy
+
+from warp.types import from_ipc_handle
+
+from warp.context import init, func, func_grad, func_replay, func_native, kernel, struct, overload
+from warp.context import is_cpu_available, is_cuda_available, is_device_available
+from warp.context import get_devices, get_preferred_device
+from warp.context import get_cuda_devices, get_cuda_device_count, get_cuda_device, map_cuda_device, unmap_cuda_device
+from warp.context import get_device, set_device, synchronize_device
+from warp.context import (
+    zeros,
+    zeros_like,
+    ones,
+    ones_like,
+    full,
+    full_like,
+    clone,
+    empty,
+    empty_like,
+    copy,
+    from_numpy,
+    launch,
+    launch_tiled,
+    synchronize,
+    force_load,
+    load_module,
+    event_from_ipc_handle,
+)
+from warp.context import set_module_options, get_module_options, get_module
+from warp.context import capture_begin, capture_end, capture_launch, capture_if, capture_while, capture_debug_dot_print
+from warp.context import Kernel, Function, Launch
+from warp.context import Stream, get_stream, set_stream, wait_stream, synchronize_stream
+from warp.context import Event, record_event, wait_event, synchronize_event, get_event_elapsed_time
+from warp.context import RegisteredGLBuffer
+from warp.context import is_mempool_supported, is_mempool_enabled, set_mempool_enabled
+from warp.context import (
+    set_mempool_release_threshold,
+    get_mempool_release_threshold,
+    get_mempool_used_mem_current,
+    get_mempool_used_mem_high,
+)
+from warp.context import is_mempool_access_supported, is_mempool_access_enabled, set_mempool_access_enabled
+from warp.context import is_peer_access_supported, is_peer_access_enabled, set_peer_access_enabled
+
+from warp.tape import Tape
+from warp.utils import ScopedTimer, ScopedDevice, ScopedStream
+from warp.utils import ScopedMempool, ScopedMempoolAccess, ScopedPeerAccess
+from warp.utils import ScopedCapture
+from warp.utils import transform_expand, quat_between_vectors
+from warp.utils import TimingResult, timing_begin, timing_end, timing_print
+from warp.utils import (
+    TIMING_KERNEL,
+    TIMING_KERNEL_BUILTIN,
+    TIMING_MEMCPY,
+    TIMING_MEMSET,
+    TIMING_GRAPH,
+    TIMING_ALL,
+)
+from warp.utils import map
+
+from warp.torch import from_torch, to_torch
+from warp.torch import dtype_from_torch, dtype_to_torch
+from warp.torch import device_from_torch, device_to_torch
+from warp.torch import stream_from_torch, stream_to_torch
+
+from warp.jax import from_jax, to_jax
+from warp.jax import dtype_from_jax, dtype_to_jax
+from warp.jax import device_from_jax, device_to_jax
+
+from warp.dlpack import from_dlpack, to_dlpack
+
+from warp.paddle import from_paddle, to_paddle
+from warp.paddle import dtype_from_paddle, dtype_to_paddle
+from warp.paddle import device_from_paddle, device_to_paddle
+from warp.paddle import stream_from_paddle
+
+from warp.build import clear_kernel_cache
+from warp.build import clear_lto_cache
+
+from warp.constants import *
+
+from . import builtins
+from warp.builtins import static
+
+from warp.math import *
+
+import warp.config as config
+
+__version__ = config.version
+
+@over
+def min(a: Scalar, b: Scalar) -> Scalar:
+    """Return the minimum of two scalars."""
+    ...
+
+@over
+def min(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """Return the element-wise minimum of two vectors."""
+    ...
+
+@over
+def min(a: Vector[Any, Scalar]) -> Scalar:
+    """Return the minimum element of a vector ``a``."""
+    ...
+
+@over
+def max(a: Scalar, b: Scalar) -> Scalar:
+    """Return the maximum of two scalars."""
+    ...
+
+@over
+def max(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """Return the element-wise maximum of two vectors."""
+    ...
+
+@over
+def max(a: Vector[Any, Scalar]) -> Scalar:
+    """Return the maximum element of a vector ``a``."""
+    ...
+
+@over
+def clamp(x: Scalar, low: Scalar, high: Scalar) -> Scalar:
+    """Clamp the value of ``x`` to the range [low, high]."""
+    ...
+
+@over
+def abs(x: Scalar) -> Scalar:
+    """Return the absolute value of ``x``."""
+    ...
+
+@over
+def abs(x: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """Return the absolute values of the elements of ``x``."""
+    ...
+
+@over
+def sign(x: Scalar) -> Scalar:
+    """Return -1 if ``x`` < 0, return 1 otherwise."""
+    ...
+
+@over
+def sign(x: Vector[Any, Scalar]) -> Scalar:
+    """Return -1 for the negative elements of ``x``, and 1 otherwise."""
+    ...
+
+@over
+def step(x: Scalar) -> Scalar:
+    """Return 1.0 if ``x`` < 0.0, return 0.0 otherwise."""
+    ...
+
+@over
+def nonzero(x: Scalar) -> Scalar:
+    """Return 1.0 if ``x`` is not equal to zero, return 0.0 otherwise."""
+    ...
+
+@over
+def sin(x: Float) -> Float:
+    """Return the sine of ``x`` in radians."""
+    ...
+
+@over
+def cos(x: Float) -> Float:
+    """Return the cosine of ``x`` in radians."""
+    ...
+
+@over
+def acos(x: Float) -> Float:
+    """Return arccos of ``x`` in radians. Inputs are automatically clamped to [-1.0, 1.0]."""
+    ...
+
+@over
+def asin(x: Float) -> Float:
+    """Return arcsin of ``x`` in radians. Inputs are automatically clamped to [-1.0, 1.0]."""
+    ...
+
+@over
+def sqrt(x: Float) -> Float:
+    """Return the square root of ``x``, where ``x`` is positive."""
+    ...
+
+@over
+def cbrt(x: Float) -> Float:
+    """Return the cube root of ``x``."""
+    ...
+
+@over
+def tan(x: Float) -> Float:
+    """Return the tangent of ``x`` in radians."""
+    ...
+
+@over
+def atan(x: Float) -> Float:
+    """Return the arctangent of ``x`` in radians."""
+    ...
+
+@over
+def atan2(y: Float, x: Float) -> Float:
+    """Return the 2-argument arctangent, atan2, of the point ``(x, y)`` in radians."""
+    ...
+
+@over
+def sinh(x: Float) -> Float:
+    """Return the sinh of ``x``."""
+    ...
+
+@over
+def cosh(x: Float) -> Float:
+    """Return the cosh of ``x``."""
+    ...
+
+@over
+def tanh(x: Float) -> Float:
+    """Return the tanh of ``x``."""
+    ...
+
+@over
+def degrees(x: Float) -> Float:
+    """Convert ``x`` from radians into degrees."""
+    ...
+
+@over
+def radians(x: Float) -> Float:
+    """Convert ``x`` from degrees into radians."""
+    ...
+
+@over
+def log(x: Float) -> Float:
+    """Return the natural logarithm (base-e) of ``x``, where ``x`` is positive."""
+    ...
+
+@over
+def log2(x: Float) -> Float:
+    """Return the binary logarithm (base-2) of ``x``, where ``x`` is positive."""
+    ...
+
+@over
+def log10(x: Float) -> Float:
+    """Return the common logarithm (base-10) of ``x``, where ``x`` is positive."""
+    ...
+
+@over
+def exp(x: Float) -> Float:
+    """Return the value of the exponential function :math:`e^x`."""
+    ...
+
+@over
+def pow(x: Float, y: Float) -> Float:
+    """Return the result of ``x`` raised to power of ``y``."""
+    ...
+
+@over
+def round(x: Float) -> Float:
+    """Return the nearest integer value to ``x``, rounding halfway cases away from zero.
+
+    This is the most intuitive form of rounding in the colloquial sense, but can be slower than other options like :func:`warp.rint()`.
+    Differs from :func:`numpy.round()`, which behaves the same way as :func:`numpy.rint()`.
+    """
+    ...
+
+@over
+def rint(x: Float) -> Float:
+    """Return the nearest integer value to ``x``, rounding halfway cases to nearest even integer.
+
+    It is generally faster than :func:`warp.round()`. Equivalent to :func:`numpy.rint()`.
+    """
+    ...
+
+@over
+def trunc(x: Float) -> Float:
+    """Return the nearest integer that is closer to zero than ``x``.
+
+    In other words, it discards the fractional part of ``x``.
+    It is similar to casting ``float(int(a))``, but preserves the negative sign when ``x`` is in the range [-0.0, -1.0).
+    Equivalent to :func:`numpy.trunc()` and :func:`numpy.fix()`.
+    """
+    ...
+
+@over
+def floor(x: Float) -> Float:
+    """Return the largest integer that is less than or equal to ``x``."""
+    ...
+
+@over
+def ceil(x: Float) -> Float:
+    """Return the smallest integer that is greater than or equal to ``x``."""
+    ...
+
+@over
+def frac(x: Float) -> Float:
+    """Retrieve the fractional part of ``x``.
+
+    In other words, it discards the integer part of ``x`` and is equivalent to ``x - trunc(x)``.
+    """
+    ...
+
+@over
+def isfinite(a: Scalar) -> bool:
+    """Return ``True`` if ``a`` is a finite number, otherwise return ``False``."""
+    ...
+
+@over
+def isfinite(a: Vector[Any, Scalar]) -> bool:
+    """Return ``True`` if all elements of the vector ``a`` are finite, otherwise return ``False``."""
+    ...
+
+@over
+def isfinite(a: Quaternion[Scalar]) -> bool:
+    """Return ``True`` if all elements of the quaternion ``a`` are finite, otherwise return ``False``."""
+    ...
+
+@over
+def isfinite(a: Matrix[Any, Any, Scalar]) -> bool:
+    """Return ``True`` if all elements of the matrix ``a`` are finite, otherwise return ``False``."""
+    ...
+
+@over
+def isnan(a: Scalar) -> bool:
+    """Return ``True`` if ``a`` is NaN, otherwise return ``False``."""
+    ...
+
+@over
+def isnan(a: Vector[Any, Scalar]) -> bool:
+    """Return ``True`` if any element of the vector ``a`` is NaN, otherwise return ``False``."""
+    ...
+
+@over
+def isnan(a: Quaternion[Scalar]) -> bool:
+    """Return ``True`` if any element of the quaternion ``a`` is NaN, otherwise return ``False``."""
+    ...
+
+@over
+def isnan(a: Matrix[Any, Any, Scalar]) -> bool:
+    """Return ``True`` if any element of the matrix ``a`` is NaN, otherwise return ``False``."""
+    ...
+
+@over
+def isinf(a: Scalar) -> bool:
+    """Return ``True`` if ``a`` is positive or negative infinity, otherwise return ``False``."""
+    ...
+
+@over
+def isinf(a: Vector[Any, Scalar]) -> bool:
+    """Return ``True`` if any element of the vector ``a`` is positive or negative infinity, otherwise return ``False``."""
+    ...
+
+@over
+def isinf(a: Quaternion[Scalar]) -> bool:
+    """Return ``True`` if any element of the quaternion ``a`` is positive or negative infinity, otherwise return ``False``."""
+    ...
+
+@over
+def isinf(a: Matrix[Any, Any, Scalar]) -> bool:
+    """Return ``True`` if any element of the matrix ``a`` is positive or negative infinity, otherwise return ``False``."""
+    ...
+
+@over
+def dot(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) -> Scalar:
+    """Compute the dot product between two vectors."""
+    ...
+
+@over
+def dot(a: Quaternion[Float], b: Quaternion[Float]) -> Float:
+    """Compute the dot product between two quaternions."""
+    ...
+
+@over
+def ddot(a: Matrix[Any, Any, Scalar], b: Matrix[Any, Any, Scalar]) -> Scalar:
+    """Compute the double dot product between two matrices."""
+    ...
+
+@over
+def argmin(a: Vector[Any, Scalar]) -> uint32:
+    """Return the index of the minimum element of a vector ``a``."""
+    ...
+
+@over
+def argmax(a: Vector[Any, Scalar]) -> uint32:
+    """Return the index of the maximum element of a vector ``a``."""
+    ...
+
+@over
+def outer(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """Compute the outer product ``a*b^T`` for two vectors."""
+    ...
+
+@over
+def cross(a: Vector[3, Scalar], b: Vector[3, Scalar]) -> Vector[3, Scalar]:
+    """Compute the cross product of two 3D vectors."""
+    ...
+
+@over
+def skew(vec: Vector[3, Scalar]) -> Matrix[3, 3, Scalar]:
+    """Compute the skew-symmetric 3x3 matrix for a 3D vector ``vec``."""
+    ...
+
+@over
+def length(a: Vector[Any, Float]) -> Float:
+    """Compute the length of a floating-point vector ``a``."""
+    ...
+
+@over
+def length(a: Quaternion[Float]) -> Float:
+    """Compute the length of a quaternion ``a``."""
+    ...
+
+@over
+def length_sq(a: Vector[Any, Scalar]) -> Scalar:
+    """Compute the squared length of a vector ``a``."""
+    ...
+
+@over
+def length_sq(a: Quaternion[Scalar]) -> Scalar:
+    """Compute the squared length of a quaternion ``a``."""
+    ...
+
+@over
+def normalize(a: Vector[Any, Float]) -> Vector[Any, Float]:
+    """Compute the normalized value of ``a``. If ``length(a)`` is 0 then the zero vector is returned."""
+    ...
+
+@over
+def normalize(a: Quaternion[Float]) -> Quaternion[Float]:
+    """Compute the normalized value of ``a``. If ``length(a)`` is 0, then the zero quaternion is returned."""
+    ...
+
+@over
+def transpose(a: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """Return the transpose of the matrix ``a``."""
+    ...
+
+@over
+def inverse(a: Matrix[2, 2, Float]) -> Matrix[Any, Any, Float]:
+    """Return the inverse of a 2x2 matrix ``a``."""
+    ...
+
+@over
+def inverse(a: Matrix[3, 3, Float]) -> Matrix[Any, Any, Float]:
+    """Return the inverse of a 3x3 matrix ``a``."""
+    ...
+
+@over
+def inverse(a: Matrix[4, 4, Float]) -> Matrix[Any, Any, Float]:
+    """Return the inverse of a 4x4 matrix ``a``."""
+    ...
+
+@over
+def determinant(a: Matrix[2, 2, Float]) -> Float:
+    """Return the determinant of a 2x2 matrix ``a``."""
+    ...
+
+@over
+def determinant(a: Matrix[3, 3, Float]) -> Float:
+    """Return the determinant of a 3x3 matrix ``a``."""
+    ...
+
+@over
+def determinant(a: Matrix[4, 4, Float]) -> Float:
+    """Return the determinant of a 4x4 matrix ``a``."""
+    ...
+
+@over
+def trace(a: Matrix[Any, Any, Scalar]) -> Scalar:
+    """Return the trace of the matrix ``a``."""
+    ...
+
+@over
+def diag(vec: Vector[Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """Returns a matrix with the components of the vector ``vec`` on the diagonal."""
+    ...
+
+@over
+def get_diag(mat: Matrix[Any, Any, Scalar]) -> Vector[Any, Scalar]:
+    """Returns a vector containing the diagonal elements of the square matrix ``mat``."""
+    ...
+
+@over
+def cw_mul(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """Component-wise multiplication of two vectors."""
+    ...
+
+@over
+def cw_mul(a: Matrix[Any, Any, Scalar], b: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """Component-wise multiplication of two matrices."""
+    ...
+
+@over
+def cw_div(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """Component-wise division of two vectors."""
+    ...
+
+@over
+def cw_div(a: Matrix[Any, Any, Scalar], b: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """Component-wise division of two matrices."""
+    ...
+
+@over
+def vector(*args: Scalar, length: int32, dtype: Scalar) -> Vector[Any, Scalar]:
+    """Construct a vector of given length and dtype."""
+    ...
+
+@over
+def matrix(pos: Vector[3, Float], rot: Quaternion[Float], scale: Vector[3, Float], dtype: Float) -> Matrix[4, 4, Float]:
+    """Construct a 4x4 transformation matrix that applies the transformations as
+    Translation(pos)*Rotation(rot)*Scaling(scale) when applied to column vectors, i.e.: y = (TRS)*x
+
+    .. warning::
+       This function has been deprecated in favor of :func:`warp.math.transform_compose()`.
+    """
+    ...
+
+@over
+def matrix(*args: Scalar, shape: Tuple[int, int], dtype: Scalar) -> Matrix[Any, Any, Scalar]:
+    """Construct a matrix. If the positional ``arg_types`` are not given, then matrix will be zero-initialized."""
+    ...
+
+@over
+def matrix_from_cols(*args: Vector[Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """Construct a matrix from column vectors."""
+    ...
+
+@over
+def matrix_from_rows(*args: Vector[Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """Construct a matrix from row vectors."""
+    ...
+
+@over
+def identity(n: int32, dtype: Scalar) -> Matrix[Any, Any, Scalar]:
+    """Create an identity matrix with shape=(n,n) with the type given by ``dtype``."""
+    ...
+
+@over
+def svd3(A: Matrix[3, 3, Float]) -> Tuple[Matrix[3, 3, Float], Vector[3, Float], Matrix[3, 3, Float]]:
+    """Compute the SVD of a 3x3 matrix ``A``. The singular values are returned in ``sigma``,
+    while the left and right basis vectors are returned in ``U`` and ``V``.
+    """
+    ...
+
+@over
+def svd3(A: Matrix[3, 3, Float], U: Matrix[3, 3, Float], sigma: Vector[3, Float], V: Matrix[3, 3, Float]):
+    """Compute the SVD of a 3x3 matrix ``A``. The singular values are returned in ``sigma``,
+    while the left and right basis vectors are returned in ``U`` and ``V``.
+    """
+    ...
+
+@over
+def svd2(A: Matrix[2, 2, Float]) -> Tuple[Matrix[2, 2, Float], Vector[2, Float], Matrix[2, 2, Float]]:
+    """Compute the SVD of a 2x2 matrix ``A``. The singular values are returned in ``sigma``,
+    while the left and right basis vectors are returned in ``U`` and ``V``.
+    """
+    ...
+
+@over
+def svd2(A: Matrix[2, 2, Float], U: Matrix[2, 2, Float], sigma: Vector[2, Float], V: Matrix[2, 2, Float]):
+    """Compute the SVD of a 2x2 matrix ``A``. The singular values are returned in ``sigma``,
+    while the left and right basis vectors are returned in ``U`` and ``V``.
+    """
+    ...
+
+@over
+def qr3(A: Matrix[3, 3, Float]) -> Tuple[Matrix[3, 3, Float], Matrix[3, 3, Float]]:
+    """Compute the QR decomposition of a 3x3 matrix ``A``. The orthogonal matrix is returned in ``Q``,
+    while the upper triangular matrix is returned in ``R``.
+    """
+    ...
+
+@over
+def qr3(A: Matrix[3, 3, Float], Q: Matrix[3, 3, Float], R: Matrix[3, 3, Float]):
+    """Compute the QR decomposition of a 3x3 matrix ``A``. The orthogonal matrix is returned in ``Q``,
+    while the upper triangular matrix is returned in ``R``.
+    """
+    ...
+
+@over
+def eig3(A: Matrix[3, 3, Float]) -> Tuple[Matrix[3, 3, Float], Vector[3, Float]]:
+    """Compute the eigendecomposition of a 3x3 matrix ``A``. The eigenvectors are returned as the columns of ``Q``,
+    while the corresponding eigenvalues are returned in ``d``.
+    """
+    ...
+
+@over
+def eig3(A: Matrix[3, 3, Float], Q: Matrix[3, 3, Float], d: Vector[3, Float]):
+    """Compute the eigendecomposition of a 3x3 matrix ``A``. The eigenvectors are returned as the columns of ``Q``,
+    while the corresponding eigenvalues are returned in ``d``.
+    """
+    ...
+
+@over
+def quaternion(dtype: Float) -> Quaternion[Float]:
+    """Construct a zero-initialized quaternion. Quaternions are laid out as
+    [ix, iy, iz, r], where ix, iy, iz are the imaginary part, and r the real part.
+    """
+    ...
+
+@over
+def quaternion(x: Float, y: Float, z: Float, w: Float, dtype: Scalar) -> Quaternion[Float]:
+    """Create a quaternion using the supplied components (type inferred from component type)."""
+    ...
+
+@over
+def quaternion(ijk: Vector[3, Float], real: Float, dtype: Float) -> Quaternion[Float]:
+    """Create a quaternion using the supplied vector/scalar (type inferred from scalar type)."""
+    ...
+
+@over
+def quaternion(quat: Quaternion[Float], dtype: Float) -> Quaternion[Float]:
+    """Construct a quaternion of type dtype from another quaternion of a different dtype."""
+    ...
+
+@over
+def quat_identity(dtype: Float) -> quatf:
+    """Construct an identity quaternion with zero imaginary part and real part of 1.0"""
+    ...
+
+@over
+def quat_from_axis_angle(axis: Vector[3, Float], angle: Float) -> Quaternion[Float]:
+    """Construct a quaternion representing a rotation of angle radians around the given axis."""
+    ...
+
+@over
+def quat_to_axis_angle(quat: Quaternion[Float]) -> Tuple[Vector[3, Float], Float]:
+    """Extract the rotation axis and angle radians a quaternion represents."""
+    ...
+
+@over
+def quat_to_axis_angle(quat: Quaternion[Float], axis: Vector[3, Float], angle: Float):
+    """Extract the rotation axis and angle radians a quaternion represents."""
+    ...
+
+@over
+def quat_from_matrix(mat: Matrix[3, 3, Float]) -> Quaternion[Float]:
+    """Construct a quaternion from a 3x3 matrix.
+
+    If the matrix is not a pure rotation, but for example includes scaling or skewing, the result is undefined.
+    """
+    ...
+
+@over
+def quat_from_matrix(mat: Matrix[4, 4, Float]) -> Quaternion[Float]:
+    """Construct a quaternion from a 4x4 matrix.
+
+    If the top-left 3x3 block of the matrix is not a pure rotation, but for example includes scaling or skewing, the result is undefined.
+    """
+    ...
+
+@over
+def quat_rpy(roll: Float, pitch: Float, yaw: Float) -> Quaternion[Float]:
+    """Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians."""
+    ...
+
+@over
+def quat_inverse(quat: Quaternion[Float]) -> Quaternion[Float]:
+    """Compute quaternion conjugate."""
+    ...
+
+@over
+def quat_rotate(quat: Quaternion[Float], vec: Vector[3, Float]) -> Vector[3, Float]:
+    """Rotate a vector by a quaternion."""
+    ...
+
+@over
+def quat_rotate_inv(quat: Quaternion[Float], vec: Vector[3, Float]) -> Vector[3, Float]:
+    """Rotate a vector by the inverse of a quaternion."""
+    ...
+
+@over
+def quat_slerp(a: Quaternion[Float], b: Quaternion[Float], t: Float) -> Quaternion[Float]:
+    """Linearly interpolate between two quaternions."""
+    ...
+
+@over
+def quat_to_matrix(quat: Quaternion[Float]) -> Matrix[3, 3, Float]:
+    """Convert a quaternion to a 3x3 rotation matrix."""
+    ...
+
+@over
+def transformation(p: Vector[3, Float], q: Quaternion[Float], dtype: Float) -> Transformation[Float]:
+    """Construct a rigid-body transformation with translation part ``p`` and rotation ``q``."""
+    ...
+
+@over
+def transformation(*args: Float, dtype: Float) -> Transformation[Float]:
+    """Construct a spatial transform vector of given dtype."""
+    ...
+
+@over
+def transform_identity(dtype: Float) -> transformf:
+    """Construct an identity transform with zero translation and identity rotation."""
+    ...
+
+@over
+def transform_get_translation(xform: Transformation[Float]) -> Vector[3, Float]:
+    """Return the translational part of a transform ``xform``."""
+    ...
+
+@over
+def transform_get_rotation(xform: Transformation[Float]) -> Quaternion[Float]:
+    """Return the rotational part of a transform ``xform``."""
+    ...
+
+@over
+def transform_set_translation(xform: Transformation[Float], p: Vector[3, Float]):
+    """Set the translational part of a transform ``xform``."""
+    ...
+
+@over
+def transform_set_rotation(xform: Transformation[Float], q: Quaternion[Float]):
+    """Set the rotational part of a transform ``xform``."""
+    ...
+
+@over
+def transform_multiply(a: Transformation[Float], b: Transformation[Float]) -> Transformation[Float]:
+    """Multiply two rigid body transformations together."""
+    ...
+
+@over
+def transform_point(xform: Transformation[Float], point: Vector[3, Float]) -> Vector[3, Float]:
+    """Apply the transform to a point ``point`` treating the homogeneous coordinate as w=1 (translation and rotation)."""
+    ...
+
+@over
+def transform_point(mat: Matrix[4, 4, Float], point: Vector[3, Float]) -> Vector[3, Float]:
+    """Apply the transform to a point ``point`` treating the homogeneous coordinate as w=1.
+
+    The transformation is applied treating ``point`` as a column vector, e.g.: ``y = mat*point``.
+
+    This is in contrast to some libraries, notably USD, which applies transforms to row vectors, ``y^T = point^T*mat^T``.
+    If the transform is coming from a library that uses row-vectors, then users should transpose the transformation
+    matrix before calling this method.
+    """
+    ...
+
+@over
+def transform_vector(xform: Transformation[Float], vec: Vector[3, Float]) -> Vector[3, Float]:
+    """Apply the transform to a vector ``vec`` treating the homogeneous coordinate as w=0 (rotation only)."""
+    ...
+
+@over
+def transform_vector(mat: Matrix[4, 4, Float], vec: Vector[3, Float]) -> Vector[3, Float]:
+    """Apply the transform to a vector ``vec`` treating the homogeneous coordinate as w=0.
+
+    The transformation is applied treating ``vec`` as a column vector, e.g.: ``y = mat*vec``.
+
+    This is in contrast to some libraries, notably USD, which applies transforms to row vectors, ``y^T = vec^T*mat^T``.
+    If the transform is coming from a library that uses row-vectors, then users should transpose the transformation
+    matrix before calling this method.
+    """
+    ...
+
+@over
+def transform_inverse(xform: Transformation[Float]) -> Transformation[Float]:
+    """Compute the inverse of the transformation ``xform``."""
+    ...
+
+@over
+def spatial_vector(dtype: Float) -> Vector[6, Float]:
+    """Zero-initialize a 6D screw vector."""
+    ...
+
+@over
+def spatial_vector(w: Vector[3, Float], v: Vector[3, Float], dtype: Float) -> Vector[6, Float]:
+    """Construct a 6D screw vector from two 3D vectors."""
+    ...
+
+@over
+def spatial_vector(wx: Float, wy: Float, wz: Float, vx: Float, vy: Float, vz: Float, dtype: Float) -> Vector[6, Float]:
+    """Construct a 6D screw vector from six values."""
+    ...
+
+@over
+def spatial_adjoint(r: Matrix[3, 3, Float], s: Matrix[3, 3, Float]) -> Matrix[6, 6, Float]:
+    """Construct a 6x6 spatial inertial matrix from two 3x3 diagonal blocks."""
+    ...
+
+@over
+def spatial_dot(a: Vector[6, Float], b: Vector[6, Float]) -> Float:
+    """Compute the dot product of two 6D screw vectors."""
+    ...
+
+@over
+def spatial_cross(a: Vector[6, Float], b: Vector[6, Float]) -> Vector[6, Float]:
+    """Compute the cross product of two 6D screw vectors."""
+    ...
+
+@over
+def spatial_cross_dual(a: Vector[6, Float], b: Vector[6, Float]) -> Vector[6, Float]:
+    """Compute the dual cross product of two 6D screw vectors."""
+    ...
+
+@over
+def spatial_top(svec: Vector[6, Float]) -> Vector[3, Float]:
+    """Return the top (first) part of a 6D screw vector."""
+    ...
+
+@over
+def spatial_bottom(svec: Vector[6, Float]) -> Vector[3, Float]:
+    """Return the bottom (second) part of a 6D screw vector."""
+    ...
+
+@over
+def spatial_jacobian(
+    S: Array[Vector[6, Float]],
+    joint_parents: Array[int32],
+    joint_qd_start: Array[int32],
+    joint_start: int32,
+    joint_count: int32,
+    J_start: int32,
+    J_out: Array[Float],
+):
+    """ """
+    ...
+
+@over
+def spatial_mass(
+    I_s: Array[Matrix[6, 6, Float]], joint_start: int32, joint_count: int32, M_start: int32, M: Array[Float]
+):
+    """ """
+    ...
+
+@over
+def tile_zeros(shape: Tuple[int, ...], dtype: Any, storage: str) -> Tile[Any, Tuple[int, ...]]:
+    """Allocate a tile of zero-initialized items.
+
+    :param shape: Shape of the output tile
+    :param dtype: Data type of output tile's elements (default float)
+    :param storage: The storage location for the tile: ``"register"`` for registers
+      (default) or ``"shared"`` for shared memory.
+    :returns: A zero-initialized tile with shape and data type as specified
+    """
+    ...
+
+@over
+def tile_ones(shape: Tuple[int, ...], dtype: Any, storage: str) -> Tile[Any, Tuple[int, ...]]:
+    """Allocate a tile of one-initialized items.
+
+    :param shape: Shape of the output tile
+    :param dtype: Data type of output tile's elements
+    :param storage: The storage location for the tile: ``"register"`` for registers
+      (default) or ``"shared"`` for shared memory.
+    :returns: A one-initialized tile with shape and data type as specified
+    """
+    ...
+
+@over
+def tile_arange(*args: Scalar, dtype: Scalar, storage: str) -> Tile[Scalar, Tuple[int]]:
+    """Generate a tile of linearly spaced elements.
+
+    :param args: Variable-length positional arguments, interpreted as:
+
+        - ``(stop,)``: Generates values from ``0`` to ``stop - 1``
+        - ``(start, stop)``: Generates values from ``start`` to ``stop - 1``
+        - ``(start, stop, step)``: Generates values from ``start`` to ``stop - 1`` with a step size
+
+    :param dtype: Data type of output tile's elements (optional, default: ``float``)
+    :param storage: The storage location for the tile: ``"register"`` for registers
+      (default) or ``"shared"`` for shared memory.
+    :returns: A tile with ``shape=(n)`` with linearly spaced elements of specified data type
+    """
+    ...
+
+@over
+def tile_load(
+    a: Array[Any], shape: Tuple[int, ...], offset: Tuple[int, ...], storage: str
+) -> Tile[Any, Tuple[int, ...]]:
+    """Loads a tile from a global memory array.
+
+    This method will cooperatively load a tile from global memory using all threads in the block.
+
+    :param a: The source array in global memory
+    :param shape: Shape of the tile to load, must have the same number of dimensions as ``a``
+    :param offset: Offset in the source array to begin reading from (optional)
+    :param storage: The storage location for the tile: ``"register"`` for registers
+      (default) or ``"shared"`` for shared memory.
+    :returns: A tile with shape as specified and data type the same as the source array
+    """
+    ...
+
+@over
+def tile_store(a: Array[Any], t: Tile[Any, Tuple[int, ...]], offset: Tuple[int, ...]):
+    """Store a tile to a global memory array.
+
+    This method will cooperatively store a tile to global memory using all threads in the block.
+
+    :param a: The destination array in global memory
+    :param t: The source tile to store data from, must have the same data type and number of dimensions as the destination array
+    :param offset: Offset in the destination array (optional)
+    """
+    ...
+
+@over
+def tile_atomic_add(
+    a: Array[Any], t: Tile[Any, Tuple[int, ...]], offset: Tuple[int, ...]
+) -> Tile[Any, Tuple[int, ...]]:
+    """Atomically add a tile onto the array `a`, each element will be updated atomically.
+
+    :param a: Array in global memory, should have the same ``dtype`` as the input tile
+    :param t: Source tile to add to the destination array
+    :param offset: Offset in the destination array (optional)
+    :returns: A tile with the same dimensions and data type as the source tile, holding the original value of the destination elements
+    """
+    ...
+
+@over
+def tile_view(
+    t: Tile[Any, Tuple[int, ...]], offset: Tuple[int, ...], shape: Tuple[int, ...]
+) -> Tile[Any, Tuple[int, ...]]:
+    """Return a slice of a given tile [offset, offset+shape], if shape is not specified it will be inferred from the unspecified offset dimensions.
+
+    :param t: Input tile to extract a subrange from
+    :param offset: Offset in the source tile
+    :param shape: Shape of the returned slice
+    :returns: A tile with dimensions given by the specified shape or the remaining source tile dimensions
+    """
+    ...
+
+@over
+def tile_squeeze(t: Tile[Any, Tuple[int, ...]], axis: Tuple[int, ...]) -> Tile[Any, Tuple[int, ...]]:
+    """Return a squeezed view of a tile with the same data.
+
+    :param t: Input tile to squeeze
+    :param axis: A subset of the entries of length one in the shape (optional)
+    :returns: The input tile but with all or a subset of the dimensions of length one removed.
+    """
+    ...
+
+@over
+def tile_reshape(t: Tile[Any, Tuple[int, ...]], shape: Tuple[int, ...]) -> Tile[Any, Tuple[int, ...]]:
+    """Return a reshaped view of a tile with the same data.
+
+    :param t: Input tile to reshape
+    :param shape: New shape for the tile
+    :returns: A tile containing the same data as the input tile, but arranged in a new shape.
+    """
+    ...
+
+@over
+def tile_astype(t: Tile[Scalar, Tuple[int, ...]], dtype: Scalar) -> Tile[Any, Tuple[int, ...]]:
+    """Return a new tile with the same data as the input tile, but with a different data type.
+
+    :param t: Input tile
+    :param dtype: New data type for the tile
+    :returns: A tile with the same data as the input tile, but with a different data type
+    """
+    ...
+
+@over
+def tile_assign(dst: Tile[Any, Tuple[int, ...]], src: Tile[Any, Tuple[int, ...]], offset: Tuple[int, ...]):
+    """Assign a tile to a subrange of a destination tile.
+
+    :param dst: The destination tile to assign to
+    :param src: The source tile to read values from
+    :param offset: Offset in the destination tile to write to
+    """
+    ...
+
+@over
+def untile(a: Tile[Any, Tuple[int, ...]]) -> Any:
+    """Convert a tile back to per-thread values.
+
+    This function converts a block-wide tile back to per-thread values.
+
+    * If the input tile is 1D, then the resulting value will be a per-thread scalar
+    * If the input tile is 2D, then the resulting value will be a per-thread vector of length M
+
+    :param a: A tile with dimensions ``shape=(M, block_dim)``
+    :returns: A single value per-thread with the same data type as the tile
+
+    This example shows how to create a linear sequence from thread variables:
+
+    .. code-block:: python
+
+        @wp.kernel
+        def compute():
+            i = wp.tid()
+
+            # create block-wide tile
+            t = wp.tile(i) * 2
+
+            # convert back to per-thread values
+            s = wp.untile(t)
+
+            print(s)
+
+        wp.launch(compute, dim=16, inputs=[], block_dim=16)
+
+    Prints:
+
+    .. code-block:: text
+
+        0
+        2
+        4
+        6
+        8
+        ...
+
+    """
+    ...
+
+@over
+def tile_transpose(a: Tile[Any, Tuple[int, int]]) -> Tile[Any, Tuple[int, int]]:
+    """Transpose a tile.
+
+    For shared memory tiles, this operation will alias the input tile.
+    Register tiles will first be transferred to shared memory before transposition.
+
+    :param a: Tile to transpose with ``shape=(M,N)``
+    :returns: Tile with ``shape=(N,M)``
+    """
+    ...
+
+@over
+def tile_broadcast(a: Tile[Any, Tuple[int, ...]], shape: Tuple[int, ...]) -> Tile[Any, Tuple[int, ...]]:
+    """Broadcast a tile.
+
+    Broadcasts the input tile ``a`` to the destination shape.
+    Broadcasting follows NumPy broadcast rules.
+
+    :param a: Tile to broadcast
+    :param shape: The shape to broadcast to
+    :returns: Tile with broadcast shape
+    """
+    ...
+
+@over
+def tile_sum(a: Tile[Scalar, Tuple[int, ...]]) -> Tile[Scalar, Tuple[1]]:
+    """Cooperatively compute the sum of the tile elements using all threads in the block.
+
+    :param a: The tile to compute the sum of
+    :returns: A single-element tile holding the sum
+
+    Example:
+
+    .. code-block:: python
+
+        @wp.kernel
+        def compute():
+            t = wp.tile_ones(dtype=float, shape=(16, 16))
+            s = wp.tile_sum(t)
+
+            print(s)
+
+        wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=64)
+
+    Prints:
+
+    .. code-block:: text
+
+        [256] = tile(shape=(1), storage=register)
+
+
+    """
+    ...
+
+@over
+def tile_sort(keys: Tile[Any, Tuple[int]], values: Tile[Any, Tuple[int]]):
+    """Cooperatively sort the elements of two tiles in ascending order based on the keys, using all threads in the block.
+
+    :param keys: Keys to sort by. Supported key types: :class:`float32`, :class:`int32`, :class:`uint32`. Must be in shared memory.
+    :param values: Values to sort along with keys. No type restrictions. Must be in shared memory.
+    :returns: No return value. Sorts both tiles in-place.
+
+    Example:
+
+    .. code-block:: python
+
+        @wp.kernel
+        def compute():
+            keys = wp.tile_arange(32, 0, -1, dtype=int, storage="shared")
+            values = wp.tile_arange(0, 32, 1, dtype=int, storage="shared")
+            wp.tile_sort(keys, values)
+
+            print(keys)
+            print(values)
+
+        wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=64)
+
+    Prints:
+
+    .. code-block:: text
+
+        [1, 2, ..., 32] = tile(shape=(32), storage=shared)
+        [31, 30, 29, ..., 0] = tile(shape=(32), storage=shared)
+
+
+    """
+    ...
+
+@over
+def tile_min(a: Tile[Scalar, Tuple[int, ...]]) -> Tile[Scalar, Tuple[1]]:
+    """Cooperatively compute the minimum of the tile elements using all threads in the block.
+
+    :param a: The tile to compute the minimum of
+    :returns: A single-element tile holding the minimum value
+
+    Example:
+
+    .. code-block:: python
+
+        @wp.kernel
+        def compute():
+            t = wp.tile_arange(64, 128)
+            s = wp.tile_min(t)
+
+            print(s)
+
+        wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=64)
+
+    Prints:
+
+    .. code-block:: text
+
+        [64] = tile(shape=(1), storage=register)
+
+
+    """
+    ...
+
+@over
+def tile_argmin(a: Tile[Scalar, Tuple[int, ...]]) -> Tile[Int, Tuple[1]]:
+    """Cooperatively compute the index of the minimum element in the tile using all threads in the block.
+
+    :param a: The tile to compute the argmin from
+    :returns: A single-element tile holding the index of the minimum value
+
+    Example:
+
+    .. code-block:: python
+
+        @wp.kernel
+        def compute():
+            t = wp.tile_arange(64, 128)
+            s = wp.tile_argmin(t)
+
+            print(s)
+
+        wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=64)
+
+    Prints:
+
+    .. code-block:: text
+
+        [0] = tile(shape=(1), storage=register)
+
+
+    """
+    ...
+
+@over
+def tile_max(a: Tile[Scalar, Tuple[int, ...]]) -> Tile[Scalar, Tuple[1]]:
+    """Cooperatively compute the maximum of the tile elements using all threads in the block.
+
+    :param a: The tile to compute the maximum from
+    :returns: A single-element tile holding the maximum value
+
+    Example:
+
+    .. code-block:: python
+
+        @wp.kernel
+        def compute():
+            t = wp.tile_arange(64, 128)
+            s = wp.tile_max(t)
+
+            print(s)
+
+        wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=64)
+
+    Prints:
+
+    .. code-block:: text
+
+        [127] = tile(shape=(1), storage=register)
+
+
+    """
+    ...
+
+@over
+def tile_argmax(a: Tile[Scalar, Tuple[int, ...]]) -> Tile[Int, Tuple[1]]:
+    """Cooperatively compute the index of the maximum element in the tile using all threads in the block.
+
+    :param a: The tile to compute the argmax from
+    :returns: A single-element tile holding the index of the maximum value
+
+    Example:
+
+    .. code-block:: python
+
+        @wp.kernel
+        def compute():
+            t = wp.tile_arange(64, 128)
+            s = wp.tile_argmax(t)
+
+            print(s)
+
+        wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=64)
+
+    Prints:
+
+    .. code-block:: text
+
+        [63] = tile(shape=(1), storage=register)
+
+
+    """
+    ...
+
+@over
+def tile_reduce(op: Callable, a: Tile[Scalar, Tuple[int, ...]]) -> Tile[Scalar, Tuple[1]]:
+    """Apply a custom reduction operator across the tile.
+
+    This function cooperatively performs a reduction using the provided operator across the tile.
+
+    :param op: A callable function that accepts two arguments and returns one argument, may be a user function or builtin
+    :param a: The input tile, the operator (or one of its overloads) must be able to accept the tile's data type
+    :returns: A single-element tile with the same data type as the input tile.
+
+    Example:
+
+    .. code-block:: python
+
+        @wp.kernel
+        def factorial():
+            t = wp.tile_arange(1, 10, dtype=int)
+            s = wp.tile_reduce(wp.mul, t)
+
+            print(s)
+
+        wp.launch_tiled(factorial, dim=[1], inputs=[], block_dim=16)
+
+    Prints:
+
+    .. code-block:: text
+
+        [362880] = tile(shape=(1), storage=register)
+
+    """
+    ...
+
+@over
+def tile_scan_inclusive(a: Tile[Scalar, Tuple[int, ...]]) -> Tile[Scalar, Tuple[int, ...]]:
+    """Inclusive scan (prefix sum) across the tile.
+
+    This function cooperatively performs an inclusive scan (cumulative sum) across the tile.
+
+    :param a: The input tile. Must be a tile of type float32, int32, or uint32.
+    :returns: A new tile containing the inclusive scan result.
+
+    Example:
+
+    .. code-block:: python
+
+        @wp.kernel
+        def scan_example():
+            t = wp.tile_arange(1, 5, dtype=int)
+            s = wp.tile_scan_inclusive(t)
+            print(s)
+
+        wp.launch_tiled(scan_example, dim=[1], inputs=[], block_dim=16)
+
+    Prints:
+
+    .. code-block:: text
+
+        [1, 3, 6, 10] = tile(shape=(4), storage=register)
+
+    """
+    ...
+
+@over
+def tile_scan_exclusive(a: Tile[Scalar, Tuple[int, ...]]) -> Tile[Scalar, Tuple[int, ...]]:
+    """Exclusive scan (prefix sum) across the tile.
+
+    This function cooperatively performs an exclusive scan (cumulative sum) across the tile.
+
+    :param a: The input tile. Must be a tile of type float32, int32, or uint32.
+    :returns: A new tile containing the exclusive scan result.
+
+    Example:
+
+    .. code-block:: python
+
+        @wp.kernel
+        def scan_example():
+            t = wp.tile_arange(1, 5, dtype=int)
+            s = wp.tile_scan_exclusive(t)
+            print(s)
+
+        wp.launch_tiled(scan_example, dim=[1], inputs=[], block_dim=16)
+
+    Prints:
+
+    .. code-block:: text
+
+        [0, 1, 3, 6] = tile(shape=(4), storage=register)
+
+    """
+    ...
+
+@over
+def tile_map(op: Callable, a: Tile[Scalar, Tuple[int, ...]]) -> Tile[Scalar, Tuple[int, ...]]:
+    """Apply a unary function onto the tile.
+
+    This function cooperatively applies a unary function to each element of the tile using all threads in the block.
+
+    :param op: A callable function that accepts one argument and returns one argument, may be a user function or builtin
+    :param a: The input tile, the operator (or one of its overloads) must be able to accept the tile's data type
+    :returns: A tile with the same dimensions and data type as the input tile.
+
+    Example:
+
+    .. code-block:: python
+
+        @wp.kernel
+        def compute():
+            t = wp.tile_arange(0.0, 1.0, 0.1, dtype=float)
+            s = wp.tile_map(wp.sin, t)
+
+            print(s)
+
+        wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=16)
+
+    Prints:
+
+    .. code-block:: text
+
+        [0 0.0998334 0.198669 0.29552 0.389418 0.479426 0.564642 0.644218 0.717356 0.783327] = tile(shape=(10), storage=register)
+
+    """
+    ...
+
+@over
+def tile_map(
+    op: Callable, a: Tile[Scalar, Tuple[int, ...]], b: Tile[Scalar, Tuple[int, ...]]
+) -> Tile[Scalar, Tuple[int, ...]]:
+    """Apply a binary function onto the tile.
+
+    This function cooperatively applies a binary function to each element of the tiles using all threads in the block.
+    Both input tiles must have the same dimensions and datatype.
+
+    :param op: A callable function that accepts two arguments and returns one argument, all of the same type, may be a user function or builtin
+    :param a: The first input tile, the operator (or one of its overloads) must be able to accept the tile's dtype
+    :param b: The second input tile, the operator (or one of its overloads) must be able to accept the tile's dtype
+    :returns: A tile with the same dimensions and datatype as the input tiles.
+
+    Example:
+
+    .. code-block:: python
+
+        @wp.kernel
+        def compute():
+            a = wp.tile_arange(0.0, 1.0, 0.1, dtype=float)
+            b = wp.tile_ones(shape=10, dtype=float)
+
+            s = wp.tile_map(wp.add, a, b)
+
+            print(s)
+
+        wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=16)
+
+    Prints:
+
+    .. code-block:: text
+
+        [1 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9] = tile(shape=(10), storage=register)
+    """
+    ...
+
+@over
+def bvh_query_aabb(id: uint64, low: vec3f, high: vec3f) -> BvhQuery:
+    """Construct an axis-aligned bounding box query against a BVH object.
+
+    This query can be used to iterate over all bounds inside a BVH.
+
+    :param id: The BVH identifier
+    :param low: The lower bound of the bounding box in BVH space
+    :param high: The upper bound of the bounding box in BVH space
+    """
+    ...
+
+@over
+def bvh_query_ray(id: uint64, start: vec3f, dir: vec3f) -> BvhQuery:
+    """Construct a ray query against a BVH object.
+
+    This query can be used to iterate over all bounds that intersect the ray.
+
+    :param id: The BVH identifier
+    :param start: The start of the ray in BVH space
+    :param dir: The direction of the ray in BVH space
+    """
+    ...
+
+@over
+def bvh_query_next(query: BvhQuery, index: int32) -> bool:
+    """Move to the next bound returned by the query.
+    The index of the current bound is stored in ``index``, returns ``False`` if there are no more overlapping bound.
+    """
+    ...
+
+@over
+def mesh_query_point(id: uint64, point: vec3f, max_dist: float32) -> MeshQueryPoint:
+    """Computes the closest point on the :class:`Mesh` with identifier ``id`` to the given ``point`` in space.
+
+    Identifies the sign of the distance using additional ray-casts to determine if the point is inside or outside.
+    This method is relatively robust, but does increase computational cost.
+    See below for additional sign determination methods.
+
+    :param id: The mesh identifier
+    :param point: The point in space to query
+    :param max_dist: Mesh faces above this distance will not be considered by the query
+    """
+    ...
+
+@over
+def mesh_query_point_no_sign(id: uint64, point: vec3f, max_dist: float32) -> MeshQueryPoint:
+    """Computes the closest point on the :class:`Mesh` with identifier ``id`` to the given ``point`` in space.
+
+    This method does not compute the sign of the point (inside/outside) which makes it faster than other point query methods.
+
+    :param id: The mesh identifier
+    :param point: The point in space to query
+    :param max_dist: Mesh faces above this distance will not be considered by the query
+    """
+    ...
+
+@over
+def mesh_query_furthest_point_no_sign(id: uint64, point: vec3f, min_dist: float32) -> MeshQueryPoint:
+    """Computes the furthest point on the mesh with identifier `id` to the given point in space.
+
+    This method does not compute the sign of the point (inside/outside).
+
+    :param id: The mesh identifier
+    :param point: The point in space to query
+    :param min_dist: Mesh faces below this distance will not be considered by the query
+    """
+    ...
+
+@over
+def mesh_query_point_sign_normal(id: uint64, point: vec3f, max_dist: float32, epsilon: float32) -> MeshQueryPoint:
+    """Computes the closest point on the :class:`Mesh` with identifier ``id`` to the given ``point`` in space.
+
+    Identifies the sign of the distance (inside/outside) using the angle-weighted pseudo normal.
+    This approach to sign determination is robust for well conditioned meshes that are watertight and non-self intersecting.
+    It is also comparatively fast to compute.
+
+    :param id: The mesh identifier
+    :param point: The point in space to query
+    :param max_dist: Mesh faces above this distance will not be considered by the query
+    :param epsilon: Epsilon treating distance values as equal, when locating the minimum distance vertex/face/edge, as a
+                    fraction of the average edge length, also for treating closest point as being on edge/vertex default 1e-3
+    """
+    ...
+
+@over
+def mesh_query_point_sign_winding_number(
+    id: uint64, point: vec3f, max_dist: float32, accuracy: float32, threshold: float32
+) -> MeshQueryPoint:
+    """Computes the closest point on the :class:`Mesh` with identifier ``id`` to the given point in space.
+
+    Identifies the sign using the winding number of the mesh relative to the query point. This method of sign determination is robust for poorly conditioned meshes
+    and provides a smooth approximation to sign even when the mesh is not watertight. This method is the most robust and accurate of the sign determination meshes
+    but also the most expensive.
+
+    .. note:: The :class:`Mesh` object must be constructed with ``support_winding_number=True`` for this method to return correct results.
+
+    :param id: The mesh identifier
+    :param point: The point in space to query
+    :param max_dist: Mesh faces above this distance will not be considered by the query
+    :param accuracy: Accuracy for computing the winding number with fast winding number method utilizing second-order dipole approximation, default 2.0
+    :param threshold: The threshold of the winding number to be considered inside, default 0.5
+    """
+    ...
+
+@over
+def mesh_query_ray(id: uint64, start: vec3f, dir: vec3f, max_t: float32) -> MeshQueryRay:
+    """Computes the closest ray hit on the :class:`Mesh` with identifier ``id``.
+
+    :param id: The mesh identifier
+    :param start: The start point of the ray
+    :param dir: The ray direction (should be normalized)
+    :param max_t: The maximum distance along the ray to check for intersections
+    """
+    ...
+
+@over
+def mesh_query_aabb(id: uint64, low: vec3f, high: vec3f) -> MeshQueryAABB:
+    """Construct an axis-aligned bounding box query against a :class:`Mesh`.
+
+    This query can be used to iterate over all triangles inside a volume.
+
+    :param id: The mesh identifier
+    :param low: The lower bound of the bounding box in mesh space
+    :param high: The upper bound of the bounding box in mesh space
+    """
+    ...
+
+@over
+def mesh_query_aabb_next(query: MeshQueryAABB, index: int32) -> bool:
+    """Move to the next triangle overlapping the query bounding box.
+
+    The index of the current face is stored in ``index``, returns ``False`` if there are no more overlapping triangles.
+    """
+    ...
+
+@over
+def mesh_eval_position(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec3f:
+    """Evaluates the position on the :class:`Mesh` given a face index and barycentric coordinates."""
+    ...
+
+@over
+def mesh_eval_velocity(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec3f:
+    """Evaluates the velocity on the :class:`Mesh` given a face index and barycentric coordinates."""
+    ...
+
+@over
+def hash_grid_query(id: uint64, point: vec3f, max_dist: float32) -> HashGridQuery:
+    """Construct a point query against a :class:`HashGrid`.
+
+    This query can be used to iterate over all neighboring point within a fixed radius from the query point.
+    """
+    ...
+
+@over
+def hash_grid_query_next(query: HashGridQuery, index: int32) -> bool:
+    """Move to the next point in the hash grid query.
+
+    The index of the current neighbor is stored in ``index``, returns ``False`` if there are no more neighbors.
+    """
+    ...
+
+@over
+def hash_grid_point_id(id: uint64, index: int32) -> int:
+    """Return the index of a point in the :class:`HashGrid`.
+
+    This can be used to reorder threads such that grid traversal occurs in a spatially coherent order.
+
+    Returns -1 if the :class:`HashGrid` has not been reserved.
+    """
+    ...
+
+@over
+def intersect_tri_tri(v0: vec3f, v1: vec3f, v2: vec3f, u0: vec3f, u1: vec3f, u2: vec3f) -> int:
+    """Tests for intersection between two triangles (v0, v1, v2) and (u0, u1, u2) using Moller's method.
+
+    Returns > 0 if triangles intersect.
+    """
+    ...
+
+@over
+def mesh_get(id: uint64) -> Mesh:
+    """Retrieves the mesh given its index."""
+    ...
+
+@over
+def mesh_eval_face_normal(id: uint64, face: int32) -> vec3f:
+    """Evaluates the face normal the mesh given a face index."""
+    ...
+
+@over
+def mesh_get_point(id: uint64, index: int32) -> vec3f:
+    """Returns the point of the mesh given a index."""
+    ...
+
+@over
+def mesh_get_velocity(id: uint64, index: int32) -> vec3f:
+    """Returns the velocity of the mesh given a index."""
+    ...
+
+@over
+def mesh_get_index(id: uint64, index: int32) -> int:
+    """Returns the point-index of the mesh given a face-vertex index."""
+    ...
+
+@over
+def closest_point_edge_edge(p1: vec3f, q1: vec3f, p2: vec3f, q2: vec3f, epsilon: float32) -> vec3f:
+    """Finds the closest points between two edges.
+
+    Returns barycentric weights to the points on each edge, as well as the closest distance between the edges.
+
+    :param p1: First point of first edge
+    :param q1: Second point of first edge
+    :param p2: First point of second edge
+    :param q2: Second point of second edge
+    :param epsilon: Zero tolerance for determining if points in an edge are degenerate.
+    :param out: vec3 output containing (s,t,d), where `s` in [0,1] is the barycentric weight for the first edge, `t` is the barycentric weight for the second edge, and `d` is the distance between the two edges at these two closest points.
+    """
+    ...
+
+@over
+def reversed(range: range_t) -> range_t:
+    """Returns the range in reversed order."""
+    ...
+
+@over
+def volume_sample(id: uint64, uvw: vec3f, sampling_mode: int32, dtype: Any) -> Any:
+    """Sample the volume of type `dtype` given by ``id`` at the volume local-space point ``uvw``.
+
+    Interpolation should be :attr:`warp.Volume.CLOSEST` or :attr:`wp.Volume.LINEAR.`
+    """
+    ...
+
+@over
+def volume_sample_grad(id: uint64, uvw: vec3f, sampling_mode: int32, grad: Any, dtype: Any) -> Any:
+    """Sample the volume given by ``id`` and its gradient at the volume local-space point ``uvw``.
+
+    Interpolation should be :attr:`warp.Volume.CLOSEST` or :attr:`wp.Volume.LINEAR.`
+    """
+    ...
+
+@over
+def volume_lookup(id: uint64, i: int32, j: int32, k: int32, dtype: Any) -> Any:
+    """Returns the value of voxel with coordinates ``i``, ``j``, ``k`` for a volume of type type `dtype`.
+
+    If the voxel at this index does not exist, this function returns the background value.
+    """
+    ...
+
+@over
+def volume_store(id: uint64, i: int32, j: int32, k: int32, value: Any):
+    """Store ``value`` at the voxel with coordinates ``i``, ``j``, ``k``."""
+    ...
+
+@over
+def volume_sample_f(id: uint64, uvw: vec3f, sampling_mode: int32) -> float:
+    """Sample the volume given by ``id`` at the volume local-space point ``uvw``.
+
+    Interpolation should be :attr:`warp.Volume.CLOSEST` or :attr:`wp.Volume.LINEAR.`
+    """
+    ...
+
+@over
+def volume_sample_grad_f(id: uint64, uvw: vec3f, sampling_mode: int32, grad: vec3f) -> float:
+    """Sample the volume and its gradient given by ``id`` at the volume local-space point ``uvw``.
+
+    Interpolation should be :attr:`warp.Volume.CLOSEST` or :attr:`wp.Volume.LINEAR.`
+    """
+    ...
+
+@over
+def volume_lookup_f(id: uint64, i: int32, j: int32, k: int32) -> float:
+    """Returns the value of voxel with coordinates ``i``, ``j``, ``k``.
+
+    If the voxel at this index does not exist, this function returns the background value
+    """
+    ...
+
+@over
+def volume_store_f(id: uint64, i: int32, j: int32, k: int32, value: float32):
+    """Store ``value`` at the voxel with coordinates ``i``, ``j``, ``k``."""
+    ...
+
+@over
+def volume_sample_v(id: uint64, uvw: vec3f, sampling_mode: int32) -> vec3f:
+    """Sample the vector volume given by ``id`` at the volume local-space point ``uvw``.
+
+    Interpolation should be :attr:`warp.Volume.CLOSEST` or :attr:`wp.Volume.LINEAR.`
+    """
+    ...
+
+@over
+def volume_lookup_v(id: uint64, i: int32, j: int32, k: int32) -> vec3f:
+    """Returns the vector value of voxel with coordinates ``i``, ``j``, ``k``.
+
+    If the voxel at this index does not exist, this function returns the background value.
+    """
+    ...
+
+@over
+def volume_store_v(id: uint64, i: int32, j: int32, k: int32, value: vec3f):
+    """Store ``value`` at the voxel with coordinates ``i``, ``j``, ``k``."""
+    ...
+
+@over
+def volume_sample_i(id: uint64, uvw: vec3f) -> int:
+    """Sample the :class:`int32` volume given by ``id`` at the volume local-space point ``uvw``."""
+    ...
+
+@over
+def volume_lookup_i(id: uint64, i: int32, j: int32, k: int32) -> int:
+    """Returns the :class:`int32` value of voxel with coordinates ``i``, ``j``, ``k``.
+
+    If the voxel at this index does not exist, this function returns the background value.
+    """
+    ...
+
+@over
+def volume_store_i(id: uint64, i: int32, j: int32, k: int32, value: int32):
+    """Store ``value`` at the voxel with coordinates ``i``, ``j``, ``k``."""
+    ...
+
+@over
+def volume_sample_index(id: uint64, uvw: vec3f, sampling_mode: int32, voxel_data: Array[Any], background: Any) -> Any:
+    """Sample the volume given by ``id`` at the volume local-space point ``uvw``.
+
+    Values for allocated voxels are read from the ``voxel_data`` array, and `background` is used as the value of non-existing voxels.
+    Interpolation should be :attr:`warp.Volume.CLOSEST` or :attr:`wp.Volume.LINEAR`.
+    This function is available for both index grids and classical volumes.
+
+    """
+    ...
+
+@over
+def volume_sample_grad_index(
+    id: uint64, uvw: vec3f, sampling_mode: int32, voxel_data: Array[Any], background: Any, grad: Any
+) -> Any:
+    """Sample the volume given by ``id`` and its gradient at the volume local-space point ``uvw``.
+
+    Values for allocated voxels are read from the ``voxel_data`` array, and `background` is used as the value of non-existing voxels.
+    Interpolation should be :attr:`warp.Volume.CLOSEST` or :attr:`wp.Volume.LINEAR`.
+    This function is available for both index grids and classical volumes.
+
+    """
+    ...
+
+@over
+def volume_lookup_index(id: uint64, i: int32, j: int32, k: int32) -> int32:
+    """Returns the index associated to the voxel with coordinates ``i``, ``j``, ``k``.
+
+    If the voxel at this index does not exist, this function returns -1.
+    This function is available for both index grids and classical volumes.
+
+    """
+    ...
+
+@over
+def volume_index_to_world(id: uint64, uvw: vec3f) -> vec3f:
+    """Transform a point ``uvw`` defined in volume index space to world space given the volume's intrinsic affine transformation."""
+    ...
+
+@over
+def volume_world_to_index(id: uint64, xyz: vec3f) -> vec3f:
+    """Transform a point ``xyz`` defined in volume world space to the volume's index space given the volume's intrinsic affine transformation."""
+    ...
+
+@over
+def volume_index_to_world_dir(id: uint64, uvw: vec3f) -> vec3f:
+    """Transform a direction ``uvw`` defined in volume index space to world space given the volume's intrinsic affine transformation."""
+    ...
+
+@over
+def volume_world_to_index_dir(id: uint64, xyz: vec3f) -> vec3f:
+    """Transform a direction ``xyz`` defined in volume world space to the volume's index space given the volume's intrinsic affine transformation."""
+    ...
+
+@over
+def rand_init(seed: int32) -> uint32:
+    """Initialize a new random number generator given a user-defined seed. Returns a 32-bit integer representing the RNG state."""
+    ...
+
+@over
+def rand_init(seed: int32, offset: int32) -> uint32:
+    """Initialize a new random number generator given a user-defined seed and an offset.
+
+    This alternative constructor can be useful in parallel programs, where a kernel as a whole should share a seed,
+    but each thread should generate uncorrelated values. In this case usage should be ``r = rand_init(seed, tid)``
+    """
+    ...
+
+@over
+def randi(state: uint32) -> int:
+    """Return a random integer in the range [-2^31, 2^31)."""
+    ...
+
+@over
+def randi(state: uint32, low: int32, high: int32) -> int:
+    """Return a random integer between [low, high)."""
+    ...
+
+@over
+def randu(state: uint32) -> uint32:
+    """Return a random unsigned integer in the range [0, 2^32)."""
+    ...
+
+@over
+def randu(state: uint32, low: uint32, high: uint32) -> uint32:
+    """Return a random unsigned integer between [low, high)."""
+    ...
+
+@over
+def randf(state: uint32) -> float:
+    """Return a random float between [0.0, 1.0)."""
+    ...
+
+@over
+def randf(state: uint32, low: float32, high: float32) -> float:
+    """Return a random float between [low, high)."""
+    ...
+
+@over
+def randn(state: uint32) -> float:
+    """Sample a normal (Gaussian) distribution of mean 0 and variance 1."""
+    ...
+
+@over
+def sample_cdf(state: uint32, cdf: Array[float32]) -> int:
+    """Inverse-transform sample a cumulative distribution function."""
+    ...
+
+@over
+def sample_triangle(state: uint32) -> vec2f:
+    """Uniformly sample a triangle. Returns sample barycentric coordinates."""
+    ...
+
+@over
+def sample_unit_ring(state: uint32) -> vec2f:
+    """Uniformly sample a ring in the xy plane."""
+    ...
+
+@over
+def sample_unit_disk(state: uint32) -> vec2f:
+    """Uniformly sample a disk in the xy plane."""
+    ...
+
+@over
+def sample_unit_sphere_surface(state: uint32) -> vec3f:
+    """Uniformly sample a unit sphere surface."""
+    ...
+
+@over
+def sample_unit_sphere(state: uint32) -> vec3f:
+    """Uniformly sample a unit sphere."""
+    ...
+
+@over
+def sample_unit_hemisphere_surface(state: uint32) -> vec3f:
+    """Uniformly sample a unit hemisphere surface."""
+    ...
+
+@over
+def sample_unit_hemisphere(state: uint32) -> vec3f:
+    """Uniformly sample a unit hemisphere."""
+    ...
+
+@over
+def sample_unit_square(state: uint32) -> vec2f:
+    """Uniformly sample a unit square."""
+    ...
+
+@over
+def sample_unit_cube(state: uint32) -> vec3f:
+    """Uniformly sample a unit cube."""
+    ...
+
+@over
+def poisson(state: uint32, lam: float32) -> uint32:
+    """Generate a random sample from a Poisson distribution.
+
+    :param state: RNG state
+    :param lam: The expected value of the distribution
+    """
+    ...
+
+@over
+def noise(state: uint32, x: float32) -> float:
+    """Non-periodic Perlin-style noise in 1D."""
+    ...
+
+@over
+def noise(state: uint32, xy: vec2f) -> float:
+    """Non-periodic Perlin-style noise in 2D."""
+    ...
+
+@over
+def noise(state: uint32, xyz: vec3f) -> float:
+    """Non-periodic Perlin-style noise in 3D."""
+    ...
+
+@over
+def noise(state: uint32, xyzt: vec4f) -> float:
+    """Non-periodic Perlin-style noise in 4D."""
+    ...
+
+@over
+def pnoise(state: uint32, x: float32, px: int32) -> float:
+    """Periodic Perlin-style noise in 1D."""
+    ...
+
+@over
+def pnoise(state: uint32, xy: vec2f, px: int32, py: int32) -> float:
+    """Periodic Perlin-style noise in 2D."""
+    ...
+
+@over
+def pnoise(state: uint32, xyz: vec3f, px: int32, py: int32, pz: int32) -> float:
+    """Periodic Perlin-style noise in 3D."""
+    ...
+
+@over
+def pnoise(state: uint32, xyzt: vec4f, px: int32, py: int32, pz: int32, pt: int32) -> float:
+    """Periodic Perlin-style noise in 4D."""
+    ...
+
+@over
+def curlnoise(state: uint32, xy: vec2f, octaves: uint32, lacunarity: float32, gain: float32) -> vec2f:
+    """Divergence-free vector field based on the gradient of a Perlin noise function."""
+    ...
+
+@over
+def curlnoise(state: uint32, xyz: vec3f, octaves: uint32, lacunarity: float32, gain: float32) -> vec3f:
+    """Divergence-free vector field based on the curl of three Perlin noise functions."""
+    ...
+
+@over
+def curlnoise(state: uint32, xyzt: vec4f, octaves: uint32, lacunarity: float32, gain: float32) -> vec3f:
+    """Divergence-free vector field based on the curl of three Perlin noise functions."""
+    ...
+
+@over
+def printf(fmt: str, *args: Any):
+    """Allows printing formatted strings using C-style format specifiers."""
+    ...
+
+@over
+def print(value: Any):
+    """Print variable to stdout"""
+    ...
+
+@over
+def breakpoint():
+    """Debugger breakpoint"""
+    ...
+
+@over
+def tid() -> int:
+    """Return the current thread index for a 1D kernel launch.
+
+    Note that this is the *global* index of the thread in the range [0, dim)
+    where dim is the parameter passed to kernel launch.
+
+    This function may not be called from user-defined Warp functions.
+    """
+    ...
+
+@over
+def tid() -> Tuple[int, int]:
+    """Return the current thread indices for a 2D kernel launch.
+
+    Use ``i,j = wp.tid()`` syntax to retrieve the coordinates inside the kernel thread grid.
+
+    This function may not be called from user-defined Warp functions.
+    """
+    ...
+
+@over
+def tid() -> Tuple[int, int, int]:
+    """Return the current thread indices for a 3D kernel launch.
+
+    Use ``i,j,k = wp.tid()`` syntax to retrieve the coordinates inside the kernel thread grid.
+
+    This function may not be called from user-defined Warp functions.
+    """
+    ...
+
+@over
+def tid() -> Tuple[int, int, int, int]:
+    """Return the current thread indices for a 4D kernel launch.
+
+    Use ``i,j,k,l = wp.tid()`` syntax to retrieve the coordinates inside the kernel thread grid.
+
+    This function may not be called from user-defined Warp functions.
+    """
+    ...
+
+@over
+def block_dim() -> int:
+    """Returns the number of threads in the current block."""
+    ...
+
+@over
+def select(cond: bool, value_if_false: Any, value_if_true: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
+
+    .. deprecated:: 1.7
+         Use :func:`where` instead, which has the more intuitive argument order:
+         ``where(cond, value_if_true, value_if_false)``.
+    """
+    ...
+
+@over
+def select(cond: int8, value_if_false: Any, value_if_true: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
+
+    .. deprecated:: 1.7
+         Use :func:`where` instead, which has the more intuitive argument order:
+         ``where(cond, value_if_true, value_if_false)``.
+    """
+    ...
+
+@over
+def select(cond: uint8, value_if_false: Any, value_if_true: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
+
+    .. deprecated:: 1.7
+         Use :func:`where` instead, which has the more intuitive argument order:
+         ``where(cond, value_if_true, value_if_false)``.
+    """
+    ...
+
+@over
+def select(cond: int16, value_if_false: Any, value_if_true: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
+
+    .. deprecated:: 1.7
+         Use :func:`where` instead, which has the more intuitive argument order:
+         ``where(cond, value_if_true, value_if_false)``.
+    """
+    ...
+
+@over
+def select(cond: uint16, value_if_false: Any, value_if_true: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
+
+    .. deprecated:: 1.7
+         Use :func:`where` instead, which has the more intuitive argument order:
+         ``where(cond, value_if_true, value_if_false)``.
+    """
+    ...
+
+@over
+def select(cond: int32, value_if_false: Any, value_if_true: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
+
+    .. deprecated:: 1.7
+         Use :func:`where` instead, which has the more intuitive argument order:
+         ``where(cond, value_if_true, value_if_false)``.
+    """
+    ...
+
+@over
+def select(cond: uint32, value_if_false: Any, value_if_true: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
+
+    .. deprecated:: 1.7
+         Use :func:`where` instead, which has the more intuitive argument order:
+         ``where(cond, value_if_true, value_if_false)``.
+    """
+    ...
+
+@over
+def select(cond: int64, value_if_false: Any, value_if_true: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
+
+    .. deprecated:: 1.7
+         Use :func:`where` instead, which has the more intuitive argument order:
+         ``where(cond, value_if_true, value_if_false)``.
+    """
+    ...
+
+@over
+def select(cond: uint64, value_if_false: Any, value_if_true: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``False`` then return ``value_if_false``, otherwise return ``value_if_true``.
+
+    .. deprecated:: 1.7
+         Use :func:`where` instead, which has the more intuitive argument order:
+         ``where(cond, value_if_true, value_if_false)``.
+    """
+    ...
+
+@over
+def select(arr: Array[Any], value_if_false: Any, value_if_true: Any) -> Any:
+    """Select between two arguments, if ``arr`` is null then return ``value_if_false``, otherwise return ``value_if_true``.
+
+    .. deprecated:: 1.7
+         Use :func:`where` instead, which has the more intuitive argument order:
+         ``where(arr, value_if_true, value_if_false)``.
+    """
+    ...
+
+@over
+def where(cond: bool, value_if_true: Any, value_if_false: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``True`` then return ``value_if_true``, otherwise return ``value_if_false``."""
+    ...
+
+@over
+def where(cond: int8, value_if_true: Any, value_if_false: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``True`` then return ``value_if_true``, otherwise return ``value_if_false``."""
+    ...
+
+@over
+def where(cond: uint8, value_if_true: Any, value_if_false: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``True`` then return ``value_if_true``, otherwise return ``value_if_false``."""
+    ...
+
+@over
+def where(cond: int16, value_if_true: Any, value_if_false: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``True`` then return ``value_if_true``, otherwise return ``value_if_false``."""
+    ...
+
+@over
+def where(cond: uint16, value_if_true: Any, value_if_false: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``True`` then return ``value_if_true``, otherwise return ``value_if_false``."""
+    ...
+
+@over
+def where(cond: int32, value_if_true: Any, value_if_false: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``True`` then return ``value_if_true``, otherwise return ``value_if_false``."""
+    ...
+
+@over
+def where(cond: uint32, value_if_true: Any, value_if_false: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``True`` then return ``value_if_true``, otherwise return ``value_if_false``."""
+    ...
+
+@over
+def where(cond: int64, value_if_true: Any, value_if_false: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``True`` then return ``value_if_true``, otherwise return ``value_if_false``."""
+    ...
+
+@over
+def where(cond: uint64, value_if_true: Any, value_if_false: Any) -> Any:
+    """Select between two arguments, if ``cond`` is ``True`` then return ``value_if_true``, otherwise return ``value_if_false``."""
+    ...
+
+@over
+def where(arr: Array[Any], value_if_true: Any, value_if_false: Any) -> Any:
+    """Select between two arguments, if ``arr`` is not null then return ``value_if_true``, otherwise return ``value_if_false``."""
+    ...
+
+@over
+def atomic_add(arr: Array[Any], i: Int, value: Any) -> Any:
+    """Atomically adds ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+    This function is automatically invoked when using the syntax ``arr[i] += value``.
+    """
+    ...
+
+@over
+def atomic_add(arr: Array[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically adds ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+    This function is automatically invoked when using the syntax ``arr[i,j] += value``.
+    """
+    ...
+
+@over
+def atomic_add(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically adds ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k] += value``.
+    """
+    ...
+
+@over
+def atomic_add(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically adds ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] += value``.
+    """
+    ...
+
+@over
+def atomic_add(arr: FabricArray[Any], i: Int, value: Any) -> Any:
+    """Atomically adds ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+    This function is automatically invoked when using the syntax ``arr[i] += value``.
+    """
+    ...
+
+@over
+def atomic_add(arr: FabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically adds ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+    This function is automatically invoked when using the syntax ``arr[i,j] += value``.
+    """
+    ...
+
+@over
+def atomic_add(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically adds ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k] += value``.
+    """
+    ...
+
+@over
+def atomic_add(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically adds ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] += value``.
+    """
+    ...
+
+@over
+def atomic_add(arr: IndexedFabricArray[Any], i: Int, value: Any) -> Any:
+    """Atomically adds ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+    This function is automatically invoked when using the syntax ``arr[i] += value``.
+    """
+    ...
+
+@over
+def atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically adds ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+    This function is automatically invoked when using the syntax ``arr[i,j] += value``.
+    """
+    ...
+
+@over
+def atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically adds ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k] += value``.
+    """
+    ...
+
+@over
+def atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically adds ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] += value``.
+    """
+    ...
+
+@over
+def atomic_sub(arr: Array[Any], i: Int, value: Any) -> Any:
+    """Atomically subtracts ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+    This function is automatically invoked when using the syntax ``arr[i] -= value``.
+    """
+    ...
+
+@over
+def atomic_sub(arr: Array[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically subtracts ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+    This function is automatically invoked when using the syntax ``arr[i,j] -= value``.
+    """
+    ...
+
+@over
+def atomic_sub(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically subtracts ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k] -= value``.
+    """
+    ...
+
+@over
+def atomic_sub(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically subtracts ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] -= value``.
+    """
+    ...
+
+@over
+def atomic_sub(arr: FabricArray[Any], i: Int, value: Any) -> Any:
+    """Atomically subtracts ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+    This function is automatically invoked when using the syntax ``arr[i] -= value``.
+    """
+    ...
+
+@over
+def atomic_sub(arr: FabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically subtracts ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+    This function is automatically invoked when using the syntax ``arr[i,j] -= value``.
+    """
+    ...
+
+@over
+def atomic_sub(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically subtracts ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k] -= value``.
+    """
+    ...
+
+@over
+def atomic_sub(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically subtracts ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] -= value``.
+    """
+    ...
+
+@over
+def atomic_sub(arr: IndexedFabricArray[Any], i: Int, value: Any) -> Any:
+    """Atomically subtracts ``value`` onto ``arr[i]`` and returns the original value of ``arr[i]``.
+    This function is automatically invoked when using the syntax ``arr[i] -= value``.
+    """
+    ...
+
+@over
+def atomic_sub(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically subtracts ``value`` onto ``arr[i,j]`` and returns the original value of ``arr[i,j]``.
+    This function is automatically invoked when using the syntax ``arr[i,j] -= value``.
+    """
+    ...
+
+@over
+def atomic_sub(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically subtracts ``value`` onto ``arr[i,j,k]`` and returns the original value of ``arr[i,j,k]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k] -= value``.
+    """
+    ...
+
+@over
+def atomic_sub(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically subtracts ``value`` onto ``arr[i,j,k,l]`` and returns the original value of ``arr[i,j,k,l]``.
+    This function is automatically invoked when using the syntax ``arr[i,j,k,l] -= value``.
+    """
+    ...
+
+@over
+def atomic_min(arr: Array[Any], i: Int, value: Any) -> Any:
+    """Compute the minimum of ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_min(arr: Array[Any], i: Int, j: Int, value: Any) -> Any:
+    """Compute the minimum of ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_min(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Compute the minimum of ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_min(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Compute the minimum of ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_min(arr: FabricArray[Any], i: Int, value: Any) -> Any:
+    """Compute the minimum of ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_min(arr: FabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Compute the minimum of ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_min(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Compute the minimum of ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_min(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Compute the minimum of ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_min(arr: IndexedFabricArray[Any], i: Int, value: Any) -> Any:
+    """Compute the minimum of ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_min(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Compute the minimum of ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_min(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Compute the minimum of ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_min(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Compute the minimum of ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_max(arr: Array[Any], i: Int, value: Any) -> Any:
+    """Compute the maximum of ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_max(arr: Array[Any], i: Int, j: Int, value: Any) -> Any:
+    """Compute the maximum of ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_max(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Compute the maximum of ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_max(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Compute the maximum of ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_max(arr: FabricArray[Any], i: Int, value: Any) -> Any:
+    """Compute the maximum of ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_max(arr: FabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Compute the maximum of ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_max(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Compute the maximum of ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_max(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Compute the maximum of ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_max(arr: IndexedFabricArray[Any], i: Int, value: Any) -> Any:
+    """Compute the maximum of ``value`` and ``arr[i]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_max(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Compute the maximum of ``value`` and ``arr[i,j]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_max(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Compute the maximum of ``value`` and ``arr[i,j,k]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_max(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Compute the maximum of ``value`` and ``arr[i,j,k,l]``, atomically update the array, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_cas(arr: Array[Any], i: Int, compare: Any, value: Any) -> Any:
+    """Atomically compare and swap ``value`` with ``arr[i]`` if ``arr[i]`` equals ``compare``, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_cas(arr: Array[Any], i: Int, j: Int, compare: Any, value: Any) -> Any:
+    """Atomically compare and swap ``value`` with ``arr[i,j]`` if ``arr[i,j]`` equals ``compare``, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_cas(arr: Array[Any], i: Int, j: Int, k: Int, compare: Any, value: Any) -> Any:
+    """Atomically compare and swap ``value`` with ``arr[i,j,k]`` if ``arr[i,j,k]`` equals ``compare``, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_cas(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, compare: Any, value: Any) -> Any:
+    """Atomically compare and swap ``value`` with ``arr[i,j,k,l]`` if ``arr[i,j,k,l]`` equals ``compare``, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_cas(arr: FabricArray[Any], i: Int, compare: Any, value: Any) -> Any:
+    """Atomically compare and swap ``value`` with ``arr[i]`` if ``arr[i]`` equals ``compare``, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_cas(arr: FabricArray[Any], i: Int, j: Int, compare: Any, value: Any) -> Any:
+    """Atomically compare and swap ``value`` with ``arr[i,j]`` if ``arr[i,j]`` equals ``compare``, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_cas(arr: FabricArray[Any], i: Int, j: Int, k: Int, compare: Any, value: Any) -> Any:
+    """Atomically compare and swap ``value`` with ``arr[i,j,k]`` if ``arr[i,j,k]`` equals ``compare``, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_cas(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, compare: Any, value: Any) -> Any:
+    """Atomically compare and swap ``value`` with ``arr[i,j,k,l]`` if ``arr[i,j,k,l]`` equals ``compare``, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_cas(arr: IndexedFabricArray[Any], i: Int, compare: Any, value: Any) -> Any:
+    """Atomically compare and swap ``value`` with ``arr[i]`` if ``arr[i]`` equals ``compare``, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_cas(arr: IndexedFabricArray[Any], i: Int, j: Int, compare: Any, value: Any) -> Any:
+    """Atomically compare and swap ``value`` with ``arr[i,j]`` if ``arr[i,j]`` equals ``compare``, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_cas(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, compare: Any, value: Any) -> Any:
+    """Atomically compare and swap ``value`` with ``arr[i,j,k]`` if ``arr[i,j,k]`` equals ``compare``, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_cas(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, compare: Any, value: Any) -> Any:
+    """Atomically compare and swap ``value`` with ``arr[i,j,k,l]`` if ``arr[i,j,k,l]`` equals ``compare``, and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_exch(arr: Array[Any], i: Int, value: Any) -> Any:
+    """Atomically exchange ``value`` with ``arr[i]`` and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_exch(arr: Array[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically exchange ``value`` with ``arr[i,j]`` and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_exch(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically exchange ``value`` with ``arr[i,j,k]`` and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_exch(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically exchange ``value`` with ``arr[i,j,k,l]`` and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_exch(arr: FabricArray[Any], i: Int, value: Any) -> Any:
+    """Atomically exchange ``value`` with ``arr[i]`` and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_exch(arr: FabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically exchange ``value`` with ``arr[i,j]`` and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_exch(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically exchange ``value`` with ``arr[i,j,k]`` and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_exch(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically exchange ``value`` with ``arr[i,j,k,l]`` and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_exch(arr: IndexedFabricArray[Any], i: Int, value: Any) -> Any:
+    """Atomically exchange ``value`` with ``arr[i]`` and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_exch(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) -> Any:
+    """Atomically exchange ``value`` with ``arr[i,j]`` and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_exch(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) -> Any:
+    """Atomically exchange ``value`` with ``arr[i,j,k]`` and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def atomic_exch(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) -> Any:
+    """Atomically exchange ``value`` with ``arr[i,j,k,l]`` and return the old value.
+
+    The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+@over
+def lerp(a: Float, b: Float, t: Float) -> Float:
+    """Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t``"""
+    ...
+
+@over
+def lerp(a: Vector[Any, Float], b: Vector[Any, Float], t: Float) -> Vector[Any, Float]:
+    """Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t``"""
+    ...
+
+@over
+def lerp(a: Matrix[Any, Any, Float], b: Matrix[Any, Any, Float], t: Float) -> Matrix[Any, Any, Float]:
+    """Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t``"""
+    ...
+
+@over
+def lerp(a: Quaternion[Float], b: Quaternion[Float], t: Float) -> Quaternion[Float]:
+    """Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t``"""
+    ...
+
+@over
+def lerp(a: Transformation[Float], b: Transformation[Float], t: Float) -> Transformation[Float]:
+    """Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t``"""
+    ...
+
+@over
+def smoothstep(a: Float, b: Float, x: Float) -> Float:
+    """Smoothly interpolate between two values ``a`` and ``b`` using a factor ``x``,
+    and return a result between 0 and 1 using a cubic Hermite interpolation after clamping.
+    """
+    ...
+
+@over
+def expect_near(a: Float, b: Float, tolerance: Float):
+    """Prints an error to stdout if ``a`` and ``b`` are not closer than tolerance in magnitude"""
+    ...
+
+@over
+def expect_near(a: Vector[Any, Float], b: Vector[Any, Float], tolerance: Float):
+    """Prints an error to stdout if any element of ``a`` and ``b`` are not closer than tolerance in magnitude"""
+    ...
+
+@over
+def expect_near(a: Quaternion[Float], b: Quaternion[Float], tolerance: Float):
+    """Prints an error to stdout if any element of ``a`` and ``b`` are not closer than tolerance in magnitude"""
+    ...
+
+@over
+def expect_near(a: Matrix[Any, Any, Float], b: Matrix[Any, Any, Float], tolerance: Float):
+    """Prints an error to stdout if any element of ``a`` and ``b`` are not closer than tolerance in magnitude"""
+    ...
+
+@over
+def lower_bound(arr: Array[Scalar], value: Scalar) -> int:
+    """Search a sorted array ``arr`` for the closest element greater than or equal to ``value``."""
+    ...
+
+@over
+def lower_bound(arr: Array[Scalar], arr_begin: int32, arr_end: int32, value: Scalar) -> int:
+    """Search a sorted array ``arr`` in the range [arr_begin, arr_end) for the closest element greater than or equal to ``value``."""
+    ...
+
+@over
+def add(a: Scalar, b: Scalar) -> Scalar:
+    """ """
+    ...
+
+@over
+def add(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+@over
+def add(a: Quaternion[Scalar], b: Quaternion[Scalar]) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+@over
+def add(a: Matrix[Any, Any, Scalar], b: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+@over
+def add(a: Transformation[Scalar], b: Transformation[Scalar]) -> Transformation[Scalar]:
+    """ """
+    ...
+
+@over
+def add(a: Tile[Any, Tuple[int, ...]], b: Tile[Any, Tuple[int, ...]]) -> Tile[Scalar, Tuple[int, ...]]:
+    """Add each element of two tiles together"""
+    ...
+
+@over
+def sub(a: Scalar, b: Scalar) -> Scalar:
+    """ """
+    ...
+
+@over
+def sub(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+@over
+def sub(a: Matrix[Any, Any, Scalar], b: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+@over
+def sub(a: Quaternion[Scalar], b: Quaternion[Scalar]) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+@over
+def sub(a: Transformation[Scalar], b: Transformation[Scalar]) -> Transformation[Scalar]:
+    """ """
+    ...
+
+@over
+def sub(a: Tile[Any, Tuple[int, ...]], b: Tile[Any, Tuple[int, ...]]) -> Tile[Scalar, Tuple[int, ...]]:
+    """Subtract each element b from a"""
+    ...
+
+@over
+def bit_and(a: Int, b: Int) -> Int:
+    """ """
+    ...
+
+@over
+def bit_or(a: Int, b: Int) -> Int:
+    """ """
+    ...
+
+@over
+def bit_xor(a: Int, b: Int) -> Int:
+    """ """
+    ...
+
+@over
+def lshift(a: Int, b: Int) -> Int:
+    """ """
+    ...
+
+@over
+def rshift(a: Int, b: Int) -> Int:
+    """ """
+    ...
+
+@over
+def invert(a: Int) -> Int:
+    """ """
+    ...
+
+@over
+def mul(a: Scalar, b: Scalar) -> Scalar:
+    """ """
+    ...
+
+@over
+def mul(a: Vector[Any, Scalar], b: Scalar) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+@over
+def mul(a: Scalar, b: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+@over
+def mul(a: Quaternion[Scalar], b: Scalar) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+@over
+def mul(a: Scalar, b: Quaternion[Scalar]) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+@over
+def mul(a: Quaternion[Scalar], b: Quaternion[Scalar]) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+@over
+def mul(a: Scalar, b: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+@over
+def mul(a: Matrix[Any, Any, Scalar], b: Scalar) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+@over
+def mul(a: Matrix[Any, Any, Scalar], b: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+@over
+def mul(a: Vector[Any, Scalar], b: Matrix[Any, Any, Scalar]) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+@over
+def mul(a: Matrix[Any, Any, Scalar], b: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+@over
+def mul(a: Transformation[Scalar], b: Transformation[Scalar]) -> Transformation[Scalar]:
+    """ """
+    ...
+
+@over
+def mul(a: Scalar, b: Transformation[Scalar]) -> Transformation[Scalar]:
+    """ """
+    ...
+
+@over
+def mul(a: Transformation[Scalar], b: Scalar) -> Transformation[Scalar]:
+    """ """
+    ...
+
+@over
+def mul(x: Tile[Any, Tuple[int, ...]], y: Scalar) -> Tile[Any, Tuple[int, ...]]:
+    """Multiply each element of a tile by a scalar"""
+    ...
+
+@over
+def mul(x: Scalar, y: Tile[Any, Tuple[int, ...]]) -> Tile[Any, Tuple[int, ...]]:
+    """Multiply each element of a tile by a scalar"""
+    ...
+
+@over
+def mod(a: Scalar, b: Scalar) -> Scalar:
+    """Modulo operation using truncated division."""
+    ...
+
+@over
+def mod(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) -> Scalar:
+    """Modulo operation using truncated division."""
+    ...
+
+@over
+def div(a: Scalar, b: Scalar) -> Scalar:
+    """ """
+    ...
+
+@over
+def div(a: Vector[Any, Scalar], b: Scalar) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+@over
+def div(a: Scalar, b: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+@over
+def div(a: Matrix[Any, Any, Scalar], b: Scalar) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+@over
+def div(a: Scalar, b: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+@over
+def div(a: Quaternion[Scalar], b: Scalar) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+@over
+def div(a: Scalar, b: Quaternion[Scalar]) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+@over
+def floordiv(a: Scalar, b: Scalar) -> Scalar:
+    """ """
+    ...
+
+@over
+def pos(x: Scalar) -> Scalar:
+    """ """
+    ...
+
+@over
+def pos(x: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+@over
+def pos(x: Quaternion[Scalar]) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+@over
+def pos(x: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+@over
+def neg(x: Scalar) -> Scalar:
+    """ """
+    ...
+
+@over
+def neg(x: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+@over
+def neg(x: Quaternion[Scalar]) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+@over
+def neg(x: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+@over
+def neg(x: Tile[Any, Tuple[int, ...]]) -> Tile[Scalar, Tuple[int, ...]]:
+    """Negate each element of a tile"""
+    ...
+
+@over
+def unot(a: bool) -> bool:
+    """ """
+    ...
+
+@over
+def unot(a: int8) -> bool:
+    """ """
+    ...
+
+@over
+def unot(a: uint8) -> bool:
+    """ """
+    ...
+
+@over
+def unot(a: int16) -> bool:
+    """ """
+    ...
+
+@over
+def unot(a: uint16) -> bool:
+    """ """
+    ...
+
+@over
+def unot(a: int32) -> bool:
+    """ """
+    ...
+
+@over
+def unot(a: uint32) -> bool:
+    """ """
+    ...
+
+@over
+def unot(a: int64) -> bool:
+    """ """
+    ...
+
+@over
+def unot(a: uint64) -> bool:
+    """ """
+    ...
+
+@over
+def unot(a: Array[Any]) -> bool:
+    """ """
+    ...
+
+@over
+def tile_diag_add(a: Tile[Any, Tuple[int, int]], d: Tile[Any, Tuple[int]]) -> Tile[Any, Tuple[int, int]]:
+    """Add a square matrix and a diagonal matrix 'd' represented as a 1D tile"""
+    ...
+
+@over
+def tile_matmul(a: Tile[Float, Tuple[int, int]], b: Tile[Float, Tuple[int, int]], out: Tile[Float, Tuple[int, int]]):
+    """Computes the matrix product and accumulates ``out += a*b``.
+
+    Supported datatypes are:
+        * fp16, fp32, fp64 (real)
+        * vec2h, vec2f, vec2d (complex)
+
+    All input and output tiles must have the same datatype. Tile data will automatically be migrated
+    to shared memory if necessary and will use TensorCore operations when available.
+
+    :param a: A tile with ``shape=(M, K)``
+    :param b: A tile with ``shape=(K, N)``
+    :param out: A tile with ``shape=(M, N)``
+
+    """
+    ...
+
+@over
+def tile_matmul(a: Tile[Float, Tuple[int, int]], b: Tile[Float, Tuple[int, int]]) -> Tile[Float, Tuple[int, int]]:
+    """Computes the matrix product ``out = a*b``.
+
+    Supported datatypes are:
+        * fp16, fp32, fp64 (real)
+        * vec2h, vec2f, vec2d (complex)
+
+    Both input tiles must have the same datatype. Tile data will automatically be migrated
+    to shared memory if necessary and will use TensorCore operations when available.
+
+    :param a: A tile with ``shape=(M, K)``
+    :param b: A tile with ``shape=(K, N)``
+    :returns: A tile with ``shape=(M, N)``
+
+    """
+    ...
+
+@over
+def tile_fft(inout: Tile[Vector[2, Float], Tuple[int, int]]) -> Tile[Vector[2, Float], Tuple[int, int]]:
+    """Compute the forward FFT along the second dimension of a 2D tile of data.
+
+    This function cooperatively computes the forward FFT on a tile of data inplace, treating each row individually.
+
+    Note that computing the adjoint is not yet supported.
+
+    Supported datatypes are:
+        * vec2f, vec2d
+
+    :param inout: The input/output tile
+    """
+    ...
+
+@over
+def tile_ifft(inout: Tile[Vector[2, Float], Tuple[int, int]]) -> Tile[Vector[2, Float], Tuple[int, int]]:
+    """Compute the inverse FFT along the second dimension of a 2D tile of data.
+
+    This function cooperatively computes the inverse FFT on a tile of data inplace, treating each row individually.
+
+    Note that computing the adjoint is not yet supported.
+
+    Supported datatypes are:
+        * vec2f, vec2d
+
+    :param inout: The input/output tile
+    """
+    ...
+
+@over
+def tile_cholesky(A: Tile[Float, Tuple[int, int]]) -> Tile[Float, Tuple[int, int]]:
+    """Compute the Cholesky factorization L of a matrix A.
+    L is lower triangular and satisfies LL^T = A.
+
+    Only the lower triangular portion of A is used for the decomposition;
+    the upper triangular part may be left unspecified.
+
+    Note that computing the adjoint is not yet supported.
+
+    Supported datatypes are:
+        * float32
+        * float64
+
+    :param A: A square, symmetric positive-definite, matrix. Only the lower triangular part of A is needed; the upper part is ignored.
+    :returns L: A square, lower triangular, matrix, such that LL^T = A
+    """
+    ...
+
+@over
+def tile_cholesky_solve(L: Tile[Float, Tuple[int, int]], y: Tile[Float, Tuple[int]]):
+    """With L such that LL^T = A, solve for x in Ax = y
+
+    Note that computing the adjoint is not yet supported.
+
+    Supported datatypes are:
+        * float32
+        * float64
+
+    :param L: A square, lower triangular, matrix, such that LL^T = A
+    :param y: A 1D or 2D tile of length M
+    :returns x: A tile of the same shape as y such that LL^T x = y
+    """
+    ...
+
+@over
+def tile_lower_solve(L: Tile[Float, Tuple[int, int]], y: Tile[Float, Tuple[int]]) -> Tile[Float, Tuple[int]]:
+    """Solve for z in Lz = y, where L is a lower triangular matrix.
+
+    This performs general forward substitution for a lower triangular system.
+
+    Note that computing the adjoint is not yet supported.
+
+    Supported datatypes are:
+        * float32
+        * float64
+
+    :param L: A square, non-singular, lower triangular matrix
+    :param y: A 1D or 2D tile with compatible shape
+    :returns z: A tile of the same shape as y such that Lz = y
+    """
+    ...
+
+@over
+def tile_upper_solve(U: Tile[Float, Tuple[int, int]], z: Tile[Float, Tuple[int]]) -> Tile[Float, Tuple[int]]:
+    """Solve for x in U x = z, where U is an upper triangular matrix.
+
+    This performs general back substitution for upper triangular systems.
+
+    Note that computing the adjoint is not yet supported.
+
+    Supported datatypes are:
+        * float32
+        * float64
+
+    :param U: A square, non-singular, upper triangular matrix
+    :param z: A 1D or 2D tile with compatible shape
+    :returns x: A tile of the same shape as z such that U x = z
+    """
+    ...
+
+@over
+def static(expr: Any) -> Any:
+    """Evaluate a static Python expression and replaces it with its result.
+
+    See the :ref:`code generation guide <static_expressions>` for more details.
+
+    The inner expression must only reference variables that are available from the current scope where the Warp kernel or function containing the expression is defined,
+    which includes constant variables and variables captured in the current closure in which the function or kernel is implemented.
+    The return type of the expression must be either a Warp function, a string, or a type that is supported inside Warp kernels and functions
+    (excluding Warp arrays since they cannot be created in a Warp kernel at the moment).
+    """
+    ...
+
+@over
+def len(a: Vector[Any, Scalar]) -> int:
+    """Return the number of elements in a vector."""
+    ...
+
+@over
+def len(a: Quaternion[Scalar]) -> int:
+    """Return the number of elements in a quaternion."""
+    ...
+
+@over
+def len(a: Matrix[Any, Any, Scalar]) -> int:
+    """Return the number of rows in a matrix."""
+    ...
+
+@over
+def len(a: Transformation[Float]) -> int:
+    """Return the number of elements in a transformation."""
+    ...
+
+@over
+def len(a: Array[Any]) -> int:
+    """Return the size of the first dimension in an array."""
+    ...
+
+@over
+def len(a: Tile[Any, Tuple[int, ...]]) -> int:
+    """Return the number of rows in a tile."""
+    ...
+
+@over
+def len(a: Tuple) -> int:
+    """Return the number of elements in a tuple."""
+    ...
+
+@over
+def norm_l1(v: Any):
+    """Computes the L1 norm of a vector v.
+
+    .. math:: \|v\|_1 = \sum_i |v_i|
+
+    Args:
+        v (Vector[Any,Float]): The vector to compute the L1 norm of.
+
+    Returns:
+        float: The L1 norm of the vector.
+    """
+    ...
+
+@over
+def norm_l2(v: Any):
+    """Computes the L2 norm of a vector v.
+
+    .. math:: \|v\|_2 = \sqrt{\sum_i v_i^2}
+
+    Args:
+        v (Vector[Any,Float]): The vector to compute the L2 norm of.
+
+    Returns:
+        float: The L2 norm of the vector.
+    """
+    ...
+
+@over
+def norm_huber(v: Any, delta: float):
+    """Computes the Huber norm of a vector v with a given delta.
+
+    .. math::
+        H(v) = \begin{cases} \frac{1}{2} \|v\|^2 & \text{if } \|v\| \leq \delta \\ \delta(\|v\| - \frac{1}{2}\delta) & \text{otherwise} \end{cases}
+
+    .. image:: /img/norm_huber.svg
+        :align: center
+
+    Args:
+        v (Vector[Any,Float]): The vector to compute the Huber norm of.
+        delta (float): The threshold value, defaults to 1.0.
+
+    Returns:
+        float: The Huber norm of the vector.
+    """
+    ...
+
+@over
+def norm_pseudo_huber(v: Any, delta: float):
+    """Computes the "pseudo" Huber norm of a vector v with a given delta.
+
+    .. math::
+        H^\prime(v) = \delta \sqrt{1 + \frac{\|v\|^2}{\delta^2}}
+
+    .. image:: /img/norm_pseudo_huber.svg
+        :align: center
+
+    Args:
+        v (Vector[Any,Float]): The vector to compute the Huber norm of.
+        delta (float): The threshold value, defaults to 1.0.
+
+    Returns:
+        float: The Huber norm of the vector.
+    """
+    ...
+
+@over
+def smooth_normalize(v: Any, delta: float):
+    """Normalizes a vector using the pseudo-Huber norm.
+
+    See :func:`norm_pseudo_huber`.
+
+    .. math::
+        \frac{v}{H^\prime(v)}
+
+    Args:
+        v (Vector[Any,Float]): The vector to normalize.
+        delta (float): The threshold value, defaults to 1.0.
+
+    Returns:
+        Vector[Any,Float]: The normalized vector.
+    """
+    ...
+
+@over
+def transform_from_matrix(mat: Matrix[4, 4, float32]) -> Transformation[float32]:
+    """Construct a transformation from a 4x4 matrix.
+
+        .. math::
+            M = \begin{bmatrix}
+            R_{00} & R_{01} & R_{02} & p_x \\
+            R_{10} & R_{11} & R_{12} & p_y \\
+            R_{20} & R_{21} & R_{22} & p_z \\
+            0 & 0 & 0 & 1
+            \end{bmatrix}
+
+        Where:
+
+        * :math:`R` is the 3x3 rotation matrix created from the orientation quaternion of the input transform.
+        * :math:`p` is the 3D position vector :math:`[p_x, p_y, p_z]` of the input transform.
+
+        Args:
+            mat (Matrix[4, 4, Float]): Matrix to convert.
+
+        Returns:
+            Transformation[Float]: The transformation.
+    """
+    ...
+
+@over
+def transform_to_matrix(xform: Transformation[float32]) -> Matrix[4, 4, float32]:
+    """Convert a transformation to a 4x4 matrix.
+
+        .. math::
+            M = \begin{bmatrix}
+            R_{00} & R_{01} & R_{02} & p_x \\
+            R_{10} & R_{11} & R_{12} & p_y \\
+            R_{20} & R_{21} & R_{22} & p_z \\
+            0 & 0 & 0 & 1
+            \end{bmatrix}
+
+        Where:
+
+        * :math:`R` is the 3x3 rotation matrix created from the orientation quaternion of the input transform.
+        * :math:`p` is the 3D position vector :math:`[p_x, p_y, p_z]` of the input transform.
+
+        Args:
+            xform (Transformation[Float]): Transformation to convert.
+
+        Returns:
+            Matrix[4, 4, Float]: The matrix.
+    """
+    ...
+
+@over
+def transform_compose(position: Vector[3, float32], rotation: Quaternion[float32], scale: Vector[3, float32]):
+    """Compose a 4x4 transformation matrix from a 3D position, quaternion orientation, and 3D scale.
+
+        .. math::
+            M = \begin{bmatrix}
+            s_x R_{00} & s_y R_{01} & s_z R_{02} & p_x \\
+            s_x R_{10} & s_y R_{11} & s_z R_{12} & p_y \\
+            s_x R_{20} & s_y R_{21} & s_z R_{22} & p_z \\
+            0 & 0 & 0 & 1
+            \end{bmatrix}
+
+        Where:
+
+        * :math:`R` is the 3x3 rotation matrix created from the orientation quaternion of the input transform.
+        * :math:`p` is the 3D position vector :math:`[p_x, p_y, p_z]` of the input transform.
+        * :math:`s` is the 3D scale vector :math:`[s_x, s_y, s_z]` of the input transform.
+
+        Args:
+            position (Vector[3, Float]): The 3D position vector.
+            rotation (Quaternion[Float]): The quaternion orientation.
+            scale (Vector[3, Float]): The 3D scale vector.
+
+        Returns:
+            Matrix[4, 4, Float]: The transformation matrix.
+    """
+    ...
+
+@over
+def transform_decompose(m: Matrix[4, 4, float32]):
+    """Decompose a 4x4 transformation matrix into 3D position, quaternion orientation, and 3D scale.
+
+        .. math::
+            M = \begin{bmatrix}
+            s_x R_{00} & s_y R_{01} & s_z R_{02} & p_x \\
+            s_x R_{10} & s_y R_{11} & s_z R_{12} & p_y \\
+            s_x R_{20} & s_y R_{21} & s_z R_{22} & p_z \\
+            0 & 0 & 0 & 1
+            \end{bmatrix}
+
+        Where:
+
+        * :math:`R` is the 3x3 rotation matrix created from the orientation quaternion of the input transform.
+        * :math:`p` is the 3D position vector :math:`[p_x, p_y, p_z]` of the input transform.
+        * :math:`s` is the 3D scale vector :math:`[s_x, s_y, s_z]` of the input transform.
+
+        Args:
+            m (Matrix[4, 4, Float]): The matrix to decompose.
+
+        Returns:
+            Tuple[Vector[3, Float], Quaternion[Float], Vector[3, Float]]: A tuple containing the position vector, quaternion orientation, and scale vector.
+    """
+    ...