warp-lang 1.0.1__py3-none-manylinux2014_aarch64.whl → 1.1.0__py3-none-manylinux2014_aarch64.whl

warp/stubs.py

@@ -1,2469 +1,2109 @@
-# 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")
-Int = TypeVar("Int")
-Float = TypeVar("Float")
-Scalar = TypeVar("Scalar")
-Vector = Generic[Length, Scalar]
-Matrix = Generic[Rows, Cols, Scalar]
-Quaternion = Generic[Float]
-Transformation = Generic[Float]
-Array = Generic[DType]
-FabricArray = Generic[DType]
-IndexedFabricArray = Generic[DType]
-
-
-from warp.types import array, array1d, array2d, array3d, array4d, constant
-from warp.types import indexedarray, indexedarray1d, indexedarray2d, indexedarray3d, indexedarray4d
-from warp.fabric import fabricarray, fabricarrayarray, indexedfabricarray, indexedfabricarrayarray
-
-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 Bvh, Mesh, HashGrid, Volume, MarchingCubes
-from warp.types import bvh_query_t, hash_grid_query_t, mesh_query_aabb_t, mesh_query_point_t, mesh_query_ray_t
-
-from warp.types import matmul, adj_matmul, batched_matmul, adj_batched_matmul, from_ptr
-
-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.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,
-    synchronize,
-    force_load,
-    load_module,
-)
-from warp.context import set_module_options, get_module_options, get_module
-from warp.context import capture_begin, capture_end, capture_launch
-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
-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
-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.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.constants import *
-
-from . import builtins
-
-import warp.config
-
-__version__ = warp.config.version
-
-
-@over
-def min(x: Scalar, y: Scalar) -> Scalar:
-    """
-    Return the minimum of two scalars.
-    """
-    ...
-
-
-@over
-def min(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
-    """
-    Return the element-wise minimum of two vectors.
-    """
-    ...
-
-
-@over
-def min(v: Vector[Any, Scalar]) -> Scalar:
-    """
-    Return the minimum element of a vector ``v``.
-    """
-    ...
-
-
-@over
-def max(x: Scalar, y: Scalar) -> Scalar:
-    """
-    Return the maximum of two scalars.
-    """
-    ...
-
-
-@over
-def max(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
-    """
-    Return the element-wise maximum of two vectors.
-    """
-    ...
-
-
-@over
-def max(v: Vector[Any, Scalar]) -> Scalar:
-    """
-    Return the maximum element of a vector ``v``.
-    """
-    ...
-
-
-@over
-def clamp(x: Scalar, a: Scalar, b: Scalar) -> Scalar:
-    """
-    Clamp the value of ``x`` to the range [a, b].
-    """
-    ...
-
-
-@over
-def abs(x: Scalar) -> Scalar:
-    """
-    Return the absolute value of ``x``.
-    """
-    ...
-
-
-@over
-def sign(x: Scalar) -> Scalar:
-    """
-    Return -1 if ``x`` < 0, return 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(x))``, 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 dot(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Scalar:
-    """
-    Compute the dot product between two vectors.
-    """
-    ...
-
-
-@over
-def dot(x: Quaternion[Float], y: Quaternion[Float]) -> Scalar:
-    """
-    Compute the dot product between two quaternions.
-    """
-    ...
-
-
-@over
-def ddot(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Scalar:
-    """
-    Compute the double dot product between two matrices.
-    """
-    ...
-
-
-@over
-def argmin(v: Vector[Any, Scalar]) -> uint32:
-    """
-    Return the index of the minimum element of a vector ``v``.
-    """
-    ...
-
-
-@over
-def argmax(v: Vector[Any, Scalar]) -> uint32:
-    """
-    Return the index of the maximum element of a vector ``v``.
-    """
-    ...
-
-
-@over
-def outer(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Matrix[Any, Any, Scalar]:
-    """
-    Compute the outer product ``x*y^T`` for two vectors.
-    """
-    ...
-
-
-@over
-def cross(x: Vector[3, Scalar], y: Vector[3, Scalar]) -> Vector[3, Scalar]:
-    """
-    Compute the cross product of two 3D vectors.
-    """
-    ...
-
-
-@over
-def skew(x: Vector[3, Scalar]):
-    """
-    Compute the skew-symmetric 3x3 matrix for a 3D vector ``x``.
-    """
-    ...
-
-
-@over
-def length(x: Vector[Any, Float]) -> Scalar:
-    """
-    Compute the length of a vector ``x``.
-    """
-    ...
-
-
-@over
-def length(x: Quaternion[Float]) -> Scalar:
-    """
-    Compute the length of a quaternion ``x``.
-    """
-    ...
-
-
-@over
-def length_sq(x: Vector[Any, Scalar]) -> Scalar:
-    """
-    Compute the squared length of a 2D vector ``x``.
-    """
-    ...
-
-
-@over
-def length_sq(x: Quaternion[Scalar]) -> Scalar:
-    """
-    Compute the squared length of a quaternion ``x``.
-    """
-    ...
-
-
-@over
-def normalize(x: Vector[Any, Float]) -> Vector[Any, Scalar]:
-    """
-    Compute the normalized value of ``x``. If ``length(x)`` is 0 then the zero vector is returned.
-    """
-    ...
-
-
-@over
-def normalize(x: Quaternion[Float]) -> Quaternion[Scalar]:
-    """
-    Compute the normalized value of ``x``. If ``length(x)`` is 0, then the zero quaternion is returned.
-    """
-    ...
-
-
-@over
-def transpose(m: Matrix[Any, Any, Scalar]):
-    """
-    Return the transpose of the matrix ``m``.
-    """
-    ...
-
-
-@over
-def inverse(m: Matrix[2, 2, Float]) -> Matrix[Any, Any, Float]:
-    """
-    Return the inverse of a 2x2 matrix ``m``.
-    """
-    ...
-
-
-@over
-def inverse(m: Matrix[3, 3, Float]) -> Matrix[Any, Any, Float]:
-    """
-    Return the inverse of a 3x3 matrix ``m``.
-    """
-    ...
-
-
-@over
-def inverse(m: Matrix[4, 4, Float]) -> Matrix[Any, Any, Float]:
-    """
-    Return the inverse of a 4x4 matrix ``m``.
-    """
-    ...
-
-
-@over
-def determinant(m: Matrix[2, 2, Float]) -> Scalar:
-    """
-    Return the determinant of a 2x2 matrix ``m``.
-    """
-    ...
-
-
-@over
-def determinant(m: Matrix[3, 3, Float]) -> Scalar:
-    """
-    Return the determinant of a 3x3 matrix ``m``.
-    """
-    ...
-
-
-@over
-def determinant(m: Matrix[4, 4, Float]) -> Scalar:
-    """
-    Return the determinant of a 4x4 matrix ``m``.
-    """
-    ...
-
-
-@over
-def trace(m: Matrix[Any, Any, Scalar]) -> Scalar:
-    """
-    Return the trace of the matrix ``m``.
-    """
-    ...
-
-
-@over
-def diag(d: Vector[Any, Scalar]) -> Matrix[Any, Any, Scalar]:
-    """
-    Returns a matrix with the components of the vector ``d`` on the diagonal.
-    """
-    ...
-
-
-@over
-def get_diag(m: Matrix[Any, Any, Scalar]) -> Vector[Any, Scalar]:
-    """
-    Returns a vector containing the diagonal elements of the square matrix ``m``.
-    """
-    ...
-
-
-@over
-def cw_mul(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
-    """
-    Component-wise multiplication of two 2D vectors.
-    """
-    ...
-
-
-@over
-def cw_mul(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
-    """
-    Component-wise multiplication of two 2D vectors.
-    """
-    ...
-
-
-@over
-def cw_div(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
-    """
-    Component-wise division of two 2D vectors.
-    """
-    ...
-
-
-@over
-def cw_div(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
-    """
-    Component-wise division of two 2D vectors.
-    """
-    ...
-
-
-@over
-def quat_identity() -> 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[Scalar]:
-    """
-    Construct a quaternion representing a rotation of angle radians around the given axis.
-    """
-    ...
-
-
-@over
-def quat_to_axis_angle(q: Quaternion[Float], axis: Vector[3, Float], angle: Float):
-    """
-    Extract the rotation axis and angle radians a quaternion represents.
-    """
-    ...
-
-
-@over
-def quat_from_matrix(m: Matrix[3, 3, Float]) -> Quaternion[Scalar]:
-    """
-    Construct a quaternion from a 3x3 matrix.
-    """
-    ...
-
-
-@over
-def quat_rpy(roll: Float, pitch: Float, yaw: Float) -> Quaternion[Scalar]:
-    """
-    Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians.
-    """
-    ...
-
-
-@over
-def quat_inverse(q: Quaternion[Float]) -> Quaternion[Scalar]:
-    """
-    Compute quaternion conjugate.
-    """
-    ...
-
-
-@over
-def quat_rotate(q: Quaternion[Float], p: Vector[3, Float]) -> Vector[3, Scalar]:
-    """
-    Rotate a vector by a quaternion.
-    """
-    ...
-
-
-@over
-def quat_rotate_inv(q: Quaternion[Float], p: Vector[3, Float]) -> Vector[3, Scalar]:
-    """
-    Rotate a vector by the inverse of a quaternion.
-    """
-    ...
-
-
-@over
-def quat_slerp(q0: Quaternion[Float], q1: Quaternion[Float], t: Float) -> Quaternion[Scalar]:
-    """
-    Linearly interpolate between two quaternions.
-    """
-    ...
-
-
-@over
-def quat_to_matrix(q: Quaternion[Float]) -> Matrix[3, 3, Scalar]:
-    """
-    Convert a quaternion to a 3x3 rotation matrix.
-    """
-    ...
-
-
-@over
-def transform_identity() -> transformf:
-    """
-    Construct an identity transform with zero translation and identity rotation.
-    """
-    ...
-
-
-@over
-def transform_get_translation(t: Transformation[Float]) -> Vector[3, Scalar]:
-    """
-    Return the translational part of a transform ``t``.
-    """
-    ...
-
-
-@over
-def transform_get_rotation(t: Transformation[Float]) -> Quaternion[Scalar]:
-    """
-    Return the rotational part of a transform ``t``.
-    """
-    ...
-
-
-@over
-def transform_multiply(a: Transformation[Float], b: Transformation[Float]) -> Transformation[Scalar]:
-    """
-    Multiply two rigid body transformations together.
-    """
-    ...
-
-
-@over
-def transform_point(t: Transformation[Scalar], p: Vector[3, Scalar]) -> Vector[3, Scalar]:
-    """
-    Apply the transform to a point ``p`` treating the homogeneous coordinate as w=1 (translation and rotation).
-    """
-    ...
-
-
-@over
-def transform_point(m: Matrix[4, 4, Scalar], p: Vector[3, Scalar]) -> Vector[3, Scalar]:
-    """
-    Apply the transform to a point ``p`` treating the homogeneous coordinate as w=1.
-       The transformation is applied treating ``p`` as a column vector, e.g.: ``y = M*p``.
-       Note this is in contrast to some libraries, notably USD, which applies transforms to row vectors, ``y^T = p^T*M^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(t: Transformation[Scalar], v: Vector[3, Scalar]) -> Vector[3, Scalar]:
-    """
-    Apply the transform to a vector ``v`` treating the homogeneous coordinate as w=0 (rotation only).
-    """
-    ...
-
-
-@over
-def transform_vector(m: Matrix[4, 4, Scalar], v: Vector[3, Scalar]) -> Vector[3, Scalar]:
-    """
-    Apply the transform to a vector ``v`` treating the homogeneous coordinate as w=0.
-       The transformation is applied treating ``v`` as a column vector, e.g.: ``y = M*v``
-       note this is in contrast to some libraries, notably USD, which applies transforms to row vectors, ``y^T = v^T*M^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(t: Transformation[Float]) -> Transformation[Float]:
-    """
-    Compute the inverse of the transformation ``t``.
-    """
-    ...
-
-
-@over
-def spatial_dot(a: Vector[6, Float], b: Vector[6, Float]) -> Scalar:
-    """
-    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(a: Vector[6, Float]):
-    """
-    Return the top (first) part of a 6D screw vector.
-    """
-    ...
-
-
-@over
-def spatial_bottom(a: Vector[6, 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 mlp(
-    weights: Array[float32],
-    bias: Array[float32],
-    activation: Callable,
-    index: int32,
-    x: Array[float32],
-    out: Array[float32],
-):
-    """
-    Evaluate a multi-layer perceptron (MLP) layer in the form: ``out = act(weights*x + bias)``.
-
-       :param weights: A layer's network weights with dimensions ``(m, n)``.
-       :param bias: An array with dimensions ``(n)``.
-       :param activation: A ``wp.func`` function that takes a single scalar float as input and returns a scalar float as output
-       :param index: The batch item to process, typically each thread will process one item in the batch, in which case
-                     index should be ``wp.tid()``
-       :param x: The feature matrix with dimensions ``(n, b)``
-       :param out: The network output with dimensions ``(m, b)``
-
-       :note: Feature and output matrices are transposed compared to some other frameworks such as PyTorch.
-              All matrices are assumed to be stored in flattened row-major memory layout (NumPy default).
-    """
-    ...
-
-
-@over
-def bvh_query_aabb(id: uint64, lower: vec3f, upper: vec3f) -> bvh_query_t:
-    """
-    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 lower: The lower bound of the bounding box in BVH space
-       :param upper: The upper bound of the bounding box in BVH space
-    """
-    ...
-
-
-@over
-def bvh_query_ray(id: uint64, start: vec3f, dir: vec3f) -> bvh_query_t:
-    """
-    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: bvh_query_t, 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) -> mesh_query_point_t:
-    """
-    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) -> mesh_query_point_t:
-    """
-    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) -> mesh_query_point_t:
-    """
-    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) -> mesh_query_point_t:
-    """
-    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
-) -> mesh_query_point_t:
-    """
-    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) -> mesh_query_ray_t:
-    """
-    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, lower: vec3f, upper: vec3f) -> mesh_query_aabb_t:
-    """
-    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 lower: The lower bound of the bounding box in mesh space
-       :param upper: The upper bound of the bounding box in mesh space
-    """
-    ...
-
-
-@over
-def mesh_query_aabb_next(query: mesh_query_aabb_t, 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) -> hash_grid_query_t:
-    """
-    Construct a point query against a :class:`HashGrid`. This query can be used to iterate over all neighboring points within a fixed radius from the query point.
-    """
-    ...
-
-
-@over
-def hash_grid_query_next(query: hash_grid_query_t, 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 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_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 [0, 2^32).
-    """
-    ...
-
-
-@over
-def randi(state: uint32, min: int32, max: int32) -> int:
-    """
-    Return a random integer between [min, max).
-    """
-    ...
-
-
-@over
-def randf(state: uint32) -> float:
-    """
-    Return a random float between [0.0, 1.0).
-    """
-    ...
-
-
-@over
-def randf(state: uint32, min: float32, max: float32) -> float:
-    """
-    Return a random float between [min, max).
-    """
-    ...
-
-
-@over
-def randn(state: uint32) -> float:
-    """
-    Sample a normal distribution.
-    """
-    ...
-
-
-@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():
-    """
-    Allows printing formatted strings using C-style format specifiers.
-    """
-    ...
-
-
-@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 select(cond: bool, arg1: Any, arg2: Any):
-    """
-    Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``
-    """
-    ...
-
-
-@over
-def select(cond: bool, arg1: Any, arg2: Any):
-    """
-    Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``
-    """
-    ...
-
-
-@over
-def select(cond: int8, arg1: Any, arg2: Any):
-    """
-    Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``
-    """
-    ...
-
-
-@over
-def select(cond: uint8, arg1: Any, arg2: Any):
-    """
-    Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``
-    """
-    ...
-
-
-@over
-def select(cond: int16, arg1: Any, arg2: Any):
-    """
-    Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``
-    """
-    ...
-
-
-@over
-def select(cond: uint16, arg1: Any, arg2: Any):
-    """
-    Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``
-    """
-    ...
-
-
-@over
-def select(cond: int32, arg1: Any, arg2: Any):
-    """
-    Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``
-    """
-    ...
-
-
-@over
-def select(cond: uint32, arg1: Any, arg2: Any):
-    """
-    Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``
-    """
-    ...
-
-
-@over
-def select(cond: int64, arg1: Any, arg2: Any):
-    """
-    Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``
-    """
-    ...
-
-
-@over
-def select(cond: uint64, arg1: Any, arg2: Any):
-    """
-    Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``
-    """
-    ...
-
-
-@over
-def select(arr: Array[Any], arg1: Any, arg2: Any):
-    """
-    Select between two arguments, if ``arr`` is null then return ``arg1``, otherwise return ``arg2``
-    """
-    ...
-
-
-@over
-def atomic_add(a: Array[Any], i: int32, value: Any):
-    """
-    Atomically add ``value`` onto ``a[i]``.
-    """
-    ...
-
-
-@over
-def atomic_add(a: Array[Any], i: int32, j: int32, value: Any):
-    """
-    Atomically add ``value`` onto ``a[i,j]``.
-    """
-    ...
-
-
-@over
-def atomic_add(a: Array[Any], i: int32, j: int32, k: int32, value: Any):
-    """
-    Atomically add ``value`` onto ``a[i,j,k]``.
-    """
-    ...
-
-
-@over
-def atomic_add(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
-    """
-    Atomically add ``value`` onto ``a[i,j,k,l]``.
-    """
-    ...
-
-
-@over
-def atomic_add(a: FabricArray[Any], i: int32, value: Any):
-    """
-    Atomically add ``value`` onto ``a[i]``.
-    """
-    ...
-
-
-@over
-def atomic_add(a: FabricArray[Any], i: int32, j: int32, value: Any):
-    """
-    Atomically add ``value`` onto ``a[i,j]``.
-    """
-    ...
-
-
-@over
-def atomic_add(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any):
-    """
-    Atomically add ``value`` onto ``a[i,j,k]``.
-    """
-    ...
-
-
-@over
-def atomic_add(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
-    """
-    Atomically add ``value`` onto ``a[i,j,k,l]``.
-    """
-    ...
-
-
-@over
-def atomic_add(a: IndexedFabricArray[Any], i: int32, value: Any):
-    """
-    Atomically add ``value`` onto ``a[i]``.
-    """
-    ...
-
-
-@over
-def atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any):
-    """
-    Atomically add ``value`` onto ``a[i,j]``.
-    """
-    ...
-
-
-@over
-def atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any):
-    """
-    Atomically add ``value`` onto ``a[i,j,k]``.
-    """
-    ...
-
-
-@over
-def atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
-    """
-    Atomically add ``value`` onto ``a[i,j,k,l]``.
-    """
-    ...
-
-
-@over
-def atomic_sub(a: Array[Any], i: int32, value: Any):
-    """
-    Atomically subtract ``value`` onto ``a[i]``.
-    """
-    ...
-
-
-@over
-def atomic_sub(a: Array[Any], i: int32, j: int32, value: Any):
-    """
-    Atomically subtract ``value`` onto ``a[i,j]``.
-    """
-    ...
-
-
-@over
-def atomic_sub(a: Array[Any], i: int32, j: int32, k: int32, value: Any):
-    """
-    Atomically subtract ``value`` onto ``a[i,j,k]``.
-    """
-    ...
-
-
-@over
-def atomic_sub(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
-    """
-    Atomically subtract ``value`` onto ``a[i,j,k,l]``.
-    """
-    ...
-
-
-@over
-def atomic_sub(a: FabricArray[Any], i: int32, value: Any):
-    """
-    Atomically subtract ``value`` onto ``a[i]``.
-    """
-    ...
-
-
-@over
-def atomic_sub(a: FabricArray[Any], i: int32, j: int32, value: Any):
-    """
-    Atomically subtract ``value`` onto ``a[i,j]``.
-    """
-    ...
-
-
-@over
-def atomic_sub(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any):
-    """
-    Atomically subtract ``value`` onto ``a[i,j,k]``.
-    """
-    ...
-
-
-@over
-def atomic_sub(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
-    """
-    Atomically subtract ``value`` onto ``a[i,j,k,l]``.
-    """
-    ...
-
-
-@over
-def atomic_sub(a: IndexedFabricArray[Any], i: int32, value: Any):
-    """
-    Atomically subtract ``value`` onto ``a[i]``.
-    """
-    ...
-
-
-@over
-def atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any):
-    """
-    Atomically subtract ``value`` onto ``a[i,j]``.
-    """
-    ...
-
-
-@over
-def atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any):
-    """
-    Atomically subtract ``value`` onto ``a[i,j,k]``.
-    """
-    ...
-
-
-@over
-def atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
-    """
-    Atomically subtract ``value`` onto ``a[i,j,k,l]``.
-    """
-    ...
-
-
-@over
-def atomic_min(a: Array[Any], i: int32, value: Any):
-    """
-    Compute the minimum of ``value`` and ``a[i]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_min(a: Array[Any], i: int32, j: int32, value: Any):
-    """
-    Compute the minimum of ``value`` and ``a[i,j]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_min(a: Array[Any], i: int32, j: int32, k: int32, value: Any):
-    """
-    Compute the minimum of ``value`` and ``a[i,j,k]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_min(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
-    """
-    Compute the minimum of ``value`` and ``a[i,j,k,l]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_min(a: FabricArray[Any], i: int32, value: Any):
-    """
-    Compute the minimum of ``value`` and ``a[i]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_min(a: FabricArray[Any], i: int32, j: int32, value: Any):
-    """
-    Compute the minimum of ``value`` and ``a[i,j]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_min(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any):
-    """
-    Compute the minimum of ``value`` and ``a[i,j,k]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_min(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
-    """
-    Compute the minimum of ``value`` and ``a[i,j,k,l]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_min(a: IndexedFabricArray[Any], i: int32, value: Any):
-    """
-    Compute the minimum of ``value`` and ``a[i]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any):
-    """
-    Compute the minimum of ``value`` and ``a[i,j]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any):
-    """
-    Compute the minimum of ``value`` and ``a[i,j,k]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
-    """
-    Compute the minimum of ``value`` and ``a[i,j,k,l]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_max(a: Array[Any], i: int32, value: Any):
-    """
-    Compute the maximum of ``value`` and ``a[i]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_max(a: Array[Any], i: int32, j: int32, value: Any):
-    """
-    Compute the maximum of ``value`` and ``a[i,j]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_max(a: Array[Any], i: int32, j: int32, k: int32, value: Any):
-    """
-    Compute the maximum of ``value`` and ``a[i,j,k]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_max(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
-    """
-    Compute the maximum of ``value`` and ``a[i,j,k,l]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_max(a: FabricArray[Any], i: int32, value: Any):
-    """
-    Compute the maximum of ``value`` and ``a[i]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_max(a: FabricArray[Any], i: int32, j: int32, value: Any):
-    """
-    Compute the maximum of ``value`` and ``a[i,j]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_max(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any):
-    """
-    Compute the maximum of ``value`` and ``a[i,j,k]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_max(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
-    """
-    Compute the maximum of ``value`` and ``a[i,j,k,l]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_max(a: IndexedFabricArray[Any], i: int32, value: Any):
-    """
-    Compute the maximum of ``value`` and ``a[i]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any):
-    """
-    Compute the maximum of ``value`` and ``a[i,j]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any):
-    """
-    Compute the maximum of ``value`` and ``a[i,j,k]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@over
-def atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
-    """
-    Compute the maximum of ``value`` and ``a[i,j,k,l]`` and atomically update the array.
-
-    Note that for vectors and matrices the operation is only atomic on a per-component basis.
-    """
-    ...
-
-
-@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(edge0: Float, edge1: Float, x: Float) -> Float:
-    """
-    Smoothly interpolate between two values ``edge0`` and ``edge1`` using a factor ``x``,
-       and return a result between 0 and 1 using a cubic Hermite interpolation after clamping.
-    """
-    ...
-
-
-@over
-def expect_near(arg1: Float, arg2: Float, tolerance: Float):
-    """
-    Prints an error to stdout if ``arg1`` and ``arg2`` are not closer than tolerance in magnitude
-    """
-    ...
-
-
-@over
-def expect_near(arg1: vec3f, arg2: vec3f, tolerance: float32):
-    """
-    Prints an error to stdout if any element of ``arg1`` and ``arg2`` 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(x: Scalar, y: Scalar) -> Scalar:
-    """ """
-    ...
-
-
-@over
-def add(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
-    """ """
-    ...
-
-
-@over
-def add(x: Quaternion[Scalar], y: Quaternion[Scalar]) -> Quaternion[Scalar]:
-    """ """
-    ...
-
-
-@over
-def add(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
-    """ """
-    ...
-
-
-@over
-def add(x: Transformation[Scalar], y: Transformation[Scalar]) -> Transformation[Scalar]:
-    """ """
-    ...
-
-
-@over
-def sub(x: Scalar, y: Scalar) -> Scalar:
-    """ """
-    ...
-
-
-@over
-def sub(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
-    """ """
-    ...
-
-
-@over
-def sub(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
-    """ """
-    ...
-
-
-@over
-def sub(x: Quaternion[Scalar], y: Quaternion[Scalar]) -> Quaternion[Scalar]:
-    """ """
-    ...
-
-
-@over
-def sub(x: Transformation[Scalar], y: Transformation[Scalar]) -> Transformation[Scalar]:
-    """ """
-    ...
-
-
-@over
-def bit_and(x: Int, y: Int) -> Int:
-    """ """
-    ...
-
-
-@over
-def bit_or(x: Int, y: Int) -> Int:
-    """ """
-    ...
-
-
-@over
-def bit_xor(x: Int, y: Int) -> Int:
-    """ """
-    ...
-
-
-@over
-def lshift(x: Int, y: Int) -> Int:
-    """ """
-    ...
-
-
-@over
-def rshift(x: Int, y: Int) -> Int:
-    """ """
-    ...
-
-
-@over
-def invert(x: Int) -> Int:
-    """ """
-    ...
-
-
-@over
-def mul(x: Scalar, y: Scalar) -> Scalar:
-    """ """
-    ...
-
-
-@over
-def mul(x: Vector[Any, Scalar], y: Scalar) -> Vector[Any, Scalar]:
-    """ """
-    ...
-
-
-@over
-def mul(x: Scalar, y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
-    """ """
-    ...
-
-
-@over
-def mul(x: Quaternion[Scalar], y: Scalar) -> Quaternion[Scalar]:
-    """ """
-    ...
-
-
-@over
-def mul(x: Scalar, y: Quaternion[Scalar]) -> Quaternion[Scalar]:
-    """ """
-    ...
-
-
-@over
-def mul(x: Quaternion[Scalar], y: Quaternion[Scalar]) -> Quaternion[Scalar]:
-    """ """
-    ...
-
-
-@over
-def mul(x: Scalar, y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
-    """ """
-    ...
-
-
-@over
-def mul(x: Matrix[Any, Any, Scalar], y: Scalar) -> Matrix[Any, Any, Scalar]:
-    """ """
-    ...
-
-
-@over
-def mul(x: Matrix[Any, Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
-    """ """
-    ...
-
-
-@over
-def mul(x: Vector[Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Vector[Any, Scalar]:
-    """ """
-    ...
-
-
-@over
-def mul(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]):
-    """ """
-    ...
-
-
-@over
-def mul(x: Transformation[Scalar], y: Transformation[Scalar]) -> Transformation[Scalar]:
-    """ """
-    ...
-
-
-@over
-def mul(x: Scalar, y: Transformation[Scalar]) -> Transformation[Scalar]:
-    """ """
-    ...
-
-
-@over
-def mul(x: Transformation[Scalar], y: Scalar) -> Transformation[Scalar]:
-    """ """
-    ...
-
-
-@over
-def mod(x: Scalar, y: Scalar) -> Scalar:
-    """ """
-    ...
-
-
-@over
-def div(x: Scalar, y: Scalar) -> Scalar:
-    """ """
-    ...
-
-
-@over
-def div(x: Vector[Any, Scalar], y: Scalar) -> Vector[Any, Scalar]:
-    """ """
-    ...
-
-
-@over
-def div(x: Scalar, y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
-    """ """
-    ...
-
-
-@over
-def div(x: Matrix[Any, Any, Scalar], y: Scalar) -> Matrix[Any, Any, Scalar]:
-    """ """
-    ...
-
-
-@over
-def div(x: Scalar, y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
-    """ """
-    ...
-
-
-@over
-def div(x: Quaternion[Scalar], y: Scalar) -> Quaternion[Scalar]:
-    """ """
-    ...
-
-
-@over
-def div(x: Scalar, y: Quaternion[Scalar]) -> Quaternion[Scalar]:
-    """ """
-    ...
-
-
-@over
-def floordiv(x: Scalar, y: 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 unot(b: bool) -> bool:
-    """ """
-    ...
-
-
-@over
-def unot(b: int8) -> bool:
-    """ """
-    ...
-
-
-@over
-def unot(b: uint8) -> bool:
-    """ """
-    ...
-
-
-@over
-def unot(b: int16) -> bool:
-    """ """
-    ...
-
-
-@over
-def unot(b: uint16) -> bool:
-    """ """
-    ...
-
-
-@over
-def unot(b: int32) -> bool:
-    """ """
-    ...
-
-
-@over
-def unot(b: uint32) -> bool:
-    """ """
-    ...
-
-
-@over
-def unot(b: int64) -> bool:
-    """ """
-    ...
-
-
-@over
-def unot(b: uint64) -> bool:
-    """ """
-    ...
-
-
-@over
-def unot(a: Array[Any]) -> bool:
-    """ """
-    ...
+# 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")
+Int = TypeVar("Int")
+Float = TypeVar("Float")
+Scalar = TypeVar("Scalar")
+Vector = Generic[Length, Scalar]
+Matrix = Generic[Rows, Cols, Scalar]
+Quaternion = Generic[Float]
+Transformation = Generic[Float]
+Array = Generic[DType]
+FabricArray = Generic[DType]
+IndexedFabricArray = Generic[DType]
+
+
+from warp.types import array, array1d, array2d, array3d, array4d, constant
+from warp.types import indexedarray, indexedarray1d, indexedarray2d, indexedarray3d, indexedarray4d
+from warp.fabric import fabricarray, fabricarrayarray, indexedfabricarray, indexedfabricarrayarray
+
+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 Bvh, Mesh, HashGrid, Volume, MarchingCubes
+from warp.types import bvh_query_t, hash_grid_query_t, mesh_query_aabb_t, mesh_query_point_t, mesh_query_ray_t
+
+from warp.types import matmul, adj_matmul, batched_matmul, adj_batched_matmul, from_ptr
+
+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.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,
+    synchronize,
+    force_load,
+    load_module,
+)
+from warp.context import set_module_options, get_module_options, get_module
+from warp.context import capture_begin, capture_end, capture_launch
+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
+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.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.constants import *
+
+from . import builtins
+
+import warp.config
+
+__version__ = warp.config.version
+
+
+@over
+def min(x: Scalar, y: Scalar) -> Scalar:
+    """Return the minimum of two scalars."""
+    ...
+
+
+@over
+def min(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """Return the element-wise minimum of two vectors."""
+    ...
+
+
+@over
+def min(v: Vector[Any, Scalar]) -> Scalar:
+    """Return the minimum element of a vector ``v``."""
+    ...
+
+
+@over
+def max(x: Scalar, y: Scalar) -> Scalar:
+    """Return the maximum of two scalars."""
+    ...
+
+
+@over
+def max(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """Return the element-wise maximum of two vectors."""
+    ...
+
+
+@over
+def max(v: Vector[Any, Scalar]) -> Scalar:
+    """Return the maximum element of a vector ``v``."""
+    ...
+
+
+@over
+def clamp(x: Scalar, a: Scalar, b: Scalar) -> Scalar:
+    """Clamp the value of ``x`` to the range [a, b]."""
+    ...
+
+
+@over
+def abs(x: Scalar) -> Scalar:
+    """Return the absolute value of ``x``."""
+    ...
+
+
+@over
+def sign(x: Scalar) -> Scalar:
+    """Return -1 if ``x`` < 0, return 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(x))``, 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 dot(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Scalar:
+    """Compute the dot product between two vectors."""
+    ...
+
+
+@over
+def dot(x: Quaternion[Float], y: Quaternion[Float]) -> Scalar:
+    """Compute the dot product between two quaternions."""
+    ...
+
+
+@over
+def ddot(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Scalar:
+    """Compute the double dot product between two matrices."""
+    ...
+
+
+@over
+def argmin(v: Vector[Any, Scalar]) -> uint32:
+    """Return the index of the minimum element of a vector ``v``."""
+    ...
+
+
+@over
+def argmax(v: Vector[Any, Scalar]) -> uint32:
+    """Return the index of the maximum element of a vector ``v``."""
+    ...
+
+
+@over
+def outer(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """Compute the outer product ``x*y^T`` for two vectors."""
+    ...
+
+
+@over
+def cross(x: Vector[3, Scalar], y: Vector[3, Scalar]) -> Vector[3, Scalar]:
+    """Compute the cross product of two 3D vectors."""
+    ...
+
+
+@over
+def skew(x: Vector[3, Scalar]):
+    """Compute the skew-symmetric 3x3 matrix for a 3D vector ``x``."""
+    ...
+
+
+@over
+def length(x: Vector[Any, Float]) -> Scalar:
+    """Compute the length of a floating-point vector ``x``."""
+    ...
+
+
+@over
+def length(x: Quaternion[Float]) -> Scalar:
+    """Compute the length of a quaternion ``x``."""
+    ...
+
+
+@over
+def length_sq(x: Vector[Any, Scalar]) -> Scalar:
+    """Compute the squared length of a vector ``x``."""
+    ...
+
+
+@over
+def length_sq(x: Quaternion[Scalar]) -> Scalar:
+    """Compute the squared length of a quaternion ``x``."""
+    ...
+
+
+@over
+def normalize(x: Vector[Any, Float]) -> Vector[Any, Scalar]:
+    """Compute the normalized value of ``x``. If ``length(x)`` is 0 then the zero vector is returned."""
+    ...
+
+
+@over
+def normalize(x: Quaternion[Float]) -> Quaternion[Scalar]:
+    """Compute the normalized value of ``x``. If ``length(x)`` is 0, then the zero quaternion is returned."""
+    ...
+
+
+@over
+def transpose(m: Matrix[Any, Any, Scalar]):
+    """Return the transpose of the matrix ``m``."""
+    ...
+
+
+@over
+def inverse(m: Matrix[2, 2, Float]) -> Matrix[Any, Any, Float]:
+    """Return the inverse of a 2x2 matrix ``m``."""
+    ...
+
+
+@over
+def inverse(m: Matrix[3, 3, Float]) -> Matrix[Any, Any, Float]:
+    """Return the inverse of a 3x3 matrix ``m``."""
+    ...
+
+
+@over
+def inverse(m: Matrix[4, 4, Float]) -> Matrix[Any, Any, Float]:
+    """Return the inverse of a 4x4 matrix ``m``."""
+    ...
+
+
+@over
+def determinant(m: Matrix[2, 2, Float]) -> Scalar:
+    """Return the determinant of a 2x2 matrix ``m``."""
+    ...
+
+
+@over
+def determinant(m: Matrix[3, 3, Float]) -> Scalar:
+    """Return the determinant of a 3x3 matrix ``m``."""
+    ...
+
+
+@over
+def determinant(m: Matrix[4, 4, Float]) -> Scalar:
+    """Return the determinant of a 4x4 matrix ``m``."""
+    ...
+
+
+@over
+def trace(m: Matrix[Any, Any, Scalar]) -> Scalar:
+    """Return the trace of the matrix ``m``."""
+    ...
+
+
+@over
+def diag(d: Vector[Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """Returns a matrix with the components of the vector ``d`` on the diagonal."""
+    ...
+
+
+@over
+def get_diag(m: Matrix[Any, Any, Scalar]) -> Vector[Any, Scalar]:
+    """Returns a vector containing the diagonal elements of the square matrix ``m``."""
+    ...
+
+
+@over
+def cw_mul(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """Component-wise multiplication of two vectors."""
+    ...
+
+
+@over
+def cw_mul(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """Component-wise multiplication of two matrices."""
+    ...
+
+
+@over
+def cw_div(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """Component-wise division of two vectors."""
+    ...
+
+
+@over
+def cw_div(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """Component-wise division of two matrices."""
+    ...
+
+
+@over
+def quat_identity() -> 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[Scalar]:
+    """Construct a quaternion representing a rotation of angle radians around the given axis."""
+    ...
+
+
+@over
+def quat_to_axis_angle(q: Quaternion[Float], axis: Vector[3, Float], angle: Float):
+    """Extract the rotation axis and angle radians a quaternion represents."""
+    ...
+
+
+@over
+def quat_from_matrix(m: Matrix[3, 3, Float]) -> Quaternion[Scalar]:
+    """Construct a quaternion from a 3x3 matrix."""
+    ...
+
+
+@over
+def quat_rpy(roll: Float, pitch: Float, yaw: Float) -> Quaternion[Scalar]:
+    """Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians."""
+    ...
+
+
+@over
+def quat_inverse(q: Quaternion[Float]) -> Quaternion[Scalar]:
+    """Compute quaternion conjugate."""
+    ...
+
+
+@over
+def quat_rotate(q: Quaternion[Float], p: Vector[3, Float]) -> Vector[3, Scalar]:
+    """Rotate a vector by a quaternion."""
+    ...
+
+
+@over
+def quat_rotate_inv(q: Quaternion[Float], p: Vector[3, Float]) -> Vector[3, Scalar]:
+    """Rotate a vector by the inverse of a quaternion."""
+    ...
+
+
+@over
+def quat_slerp(q0: Quaternion[Float], q1: Quaternion[Float], t: Float) -> Quaternion[Scalar]:
+    """Linearly interpolate between two quaternions."""
+    ...
+
+
+@over
+def quat_to_matrix(q: Quaternion[Float]) -> Matrix[3, 3, Scalar]:
+    """Convert a quaternion to a 3x3 rotation matrix."""
+    ...
+
+
+@over
+def transform_identity() -> transformf:
+    """Construct an identity transform with zero translation and identity rotation."""
+    ...
+
+
+@over
+def transform_get_translation(t: Transformation[Float]) -> Vector[3, Scalar]:
+    """Return the translational part of a transform ``t``."""
+    ...
+
+
+@over
+def transform_get_rotation(t: Transformation[Float]) -> Quaternion[Scalar]:
+    """Return the rotational part of a transform ``t``."""
+    ...
+
+
+@over
+def transform_multiply(a: Transformation[Float], b: Transformation[Float]) -> Transformation[Scalar]:
+    """Multiply two rigid body transformations together."""
+    ...
+
+
+@over
+def transform_point(t: Transformation[Scalar], p: Vector[3, Scalar]) -> Vector[3, Scalar]:
+    """Apply the transform to a point ``p`` treating the homogeneous coordinate as w=1 (translation and rotation)."""
+    ...
+
+
+@over
+def transform_point(m: Matrix[4, 4, Scalar], p: Vector[3, Scalar]) -> Vector[3, Scalar]:
+    """Apply the transform to a point ``p`` treating the homogeneous coordinate as w=1.
+
+    The transformation is applied treating ``p`` as a column vector, e.g.: ``y = M*p``.
+    Note this is in contrast to some libraries, notably USD, which applies transforms to row vectors, ``y^T = p^T*M^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(t: Transformation[Scalar], v: Vector[3, Scalar]) -> Vector[3, Scalar]:
+    """Apply the transform to a vector ``v`` treating the homogeneous coordinate as w=0 (rotation only)."""
+    ...
+
+
+@over
+def transform_vector(m: Matrix[4, 4, Scalar], v: Vector[3, Scalar]) -> Vector[3, Scalar]:
+    """Apply the transform to a vector ``v`` treating the homogeneous coordinate as w=0.
+
+    The transformation is applied treating ``v`` as a column vector, e.g.: ``y = M*v``
+    note this is in contrast to some libraries, notably USD, which applies transforms to row vectors, ``y^T = v^T*M^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(t: Transformation[Float]) -> Transformation[Float]:
+    """Compute the inverse of the transformation ``t``."""
+    ...
+
+
+@over
+def spatial_dot(a: Vector[6, Float], b: Vector[6, Float]) -> Scalar:
+    """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(a: Vector[6, Float]):
+    """Return the top (first) part of a 6D screw vector."""
+    ...
+
+
+@over
+def spatial_bottom(a: Vector[6, 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 mlp(
+    weights: Array[float32],
+    bias: Array[float32],
+    activation: Callable,
+    index: int32,
+    x: Array[float32],
+    out: Array[float32],
+):
+    """Evaluate a multi-layer perceptron (MLP) layer in the form: ``out = act(weights*x + bias)``.
+
+    :param weights: A layer's network weights with dimensions ``(m, n)``.
+    :param bias: An array with dimensions ``(n)``.
+    :param activation: A ``wp.func`` function that takes a single scalar float as input and returns a scalar float as output
+    :param index: The batch item to process, typically each thread will process one item in the batch, in which case
+                  index should be ``wp.tid()``
+    :param x: The feature matrix with dimensions ``(n, b)``
+    :param out: The network output with dimensions ``(m, b)``
+
+    :note: Feature and output matrices are transposed compared to some other frameworks such as PyTorch.
+           All matrices are assumed to be stored in flattened row-major memory layout (NumPy default).
+    """
+    ...
+
+
+@over
+def bvh_query_aabb(id: uint64, lower: vec3f, upper: vec3f) -> bvh_query_t:
+    """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 lower: The lower bound of the bounding box in BVH space
+    :param upper: The upper bound of the bounding box in BVH space
+    """
+    ...
+
+
+@over
+def bvh_query_ray(id: uint64, start: vec3f, dir: vec3f) -> bvh_query_t:
+    """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: bvh_query_t, 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) -> mesh_query_point_t:
+    """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) -> mesh_query_point_t:
+    """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) -> mesh_query_point_t:
+    """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) -> mesh_query_point_t:
+    """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
+) -> mesh_query_point_t:
+    """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) -> mesh_query_ray_t:
+    """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, lower: vec3f, upper: vec3f) -> mesh_query_aabb_t:
+    """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 lower: The lower bound of the bounding box in mesh space
+    :param upper: The upper bound of the bounding box in mesh space
+    """
+    ...
+
+
+@over
+def mesh_query_aabb_next(query: mesh_query_aabb_t, 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) -> hash_grid_query_t:
+    """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: hash_grid_query_t, 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 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_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 [0, 2^32)."""
+    ...
+
+
+@over
+def randi(state: uint32, min: int32, max: int32) -> int:
+    """Return a random integer between [min, max)."""
+    ...
+
+
+@over
+def randf(state: uint32) -> float:
+    """Return a random float between [0.0, 1.0)."""
+    ...
+
+
+@over
+def randf(state: uint32, min: float32, max: float32) -> float:
+    """Return a random float between [min, max)."""
+    ...
+
+
+@over
+def randn(state: uint32) -> float:
+    """Sample a normal distribution."""
+    ...
+
+
+@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():
+    """Allows printing formatted strings using C-style format specifiers."""
+    ...
+
+
+@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 select(cond: bool, arg1: Any, arg2: Any):
+    """Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``"""
+    ...
+
+
+@over
+def select(cond: int8, arg1: Any, arg2: Any):
+    """Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``"""
+    ...
+
+
+@over
+def select(cond: uint8, arg1: Any, arg2: Any):
+    """Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``"""
+    ...
+
+
+@over
+def select(cond: int16, arg1: Any, arg2: Any):
+    """Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``"""
+    ...
+
+
+@over
+def select(cond: uint16, arg1: Any, arg2: Any):
+    """Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``"""
+    ...
+
+
+@over
+def select(cond: int32, arg1: Any, arg2: Any):
+    """Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``"""
+    ...
+
+
+@over
+def select(cond: uint32, arg1: Any, arg2: Any):
+    """Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``"""
+    ...
+
+
+@over
+def select(cond: int64, arg1: Any, arg2: Any):
+    """Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``"""
+    ...
+
+
+@over
+def select(cond: uint64, arg1: Any, arg2: Any):
+    """Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2``"""
+    ...
+
+
+@over
+def select(arr: Array[Any], arg1: Any, arg2: Any):
+    """Select between two arguments, if ``arr`` is null then return ``arg1``, otherwise return ``arg2``"""
+    ...
+
+
+@over
+def atomic_add(a: Array[Any], i: int32, value: Any):
+    """Atomically add ``value`` onto ``a[i]``."""
+    ...
+
+
+@over
+def atomic_add(a: Array[Any], i: int32, j: int32, value: Any):
+    """Atomically add ``value`` onto ``a[i,j]``."""
+    ...
+
+
+@over
+def atomic_add(a: Array[Any], i: int32, j: int32, k: int32, value: Any):
+    """Atomically add ``value`` onto ``a[i,j,k]``."""
+    ...
+
+
+@over
+def atomic_add(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
+    """Atomically add ``value`` onto ``a[i,j,k,l]``."""
+    ...
+
+
+@over
+def atomic_add(a: FabricArray[Any], i: int32, value: Any):
+    """Atomically add ``value`` onto ``a[i]``."""
+    ...
+
+
+@over
+def atomic_add(a: FabricArray[Any], i: int32, j: int32, value: Any):
+    """Atomically add ``value`` onto ``a[i,j]``."""
+    ...
+
+
+@over
+def atomic_add(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any):
+    """Atomically add ``value`` onto ``a[i,j,k]``."""
+    ...
+
+
+@over
+def atomic_add(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
+    """Atomically add ``value`` onto ``a[i,j,k,l]``."""
+    ...
+
+
+@over
+def atomic_add(a: IndexedFabricArray[Any], i: int32, value: Any):
+    """Atomically add ``value`` onto ``a[i]``."""
+    ...
+
+
+@over
+def atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any):
+    """Atomically add ``value`` onto ``a[i,j]``."""
+    ...
+
+
+@over
+def atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any):
+    """Atomically add ``value`` onto ``a[i,j,k]``."""
+    ...
+
+
+@over
+def atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
+    """Atomically add ``value`` onto ``a[i,j,k,l]``."""
+    ...
+
+
+@over
+def atomic_sub(a: Array[Any], i: int32, value: Any):
+    """Atomically subtract ``value`` onto ``a[i]``."""
+    ...
+
+
+@over
+def atomic_sub(a: Array[Any], i: int32, j: int32, value: Any):
+    """Atomically subtract ``value`` onto ``a[i,j]``."""
+    ...
+
+
+@over
+def atomic_sub(a: Array[Any], i: int32, j: int32, k: int32, value: Any):
+    """Atomically subtract ``value`` onto ``a[i,j,k]``."""
+    ...
+
+
+@over
+def atomic_sub(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
+    """Atomically subtract ``value`` onto ``a[i,j,k,l]``."""
+    ...
+
+
+@over
+def atomic_sub(a: FabricArray[Any], i: int32, value: Any):
+    """Atomically subtract ``value`` onto ``a[i]``."""
+    ...
+
+
+@over
+def atomic_sub(a: FabricArray[Any], i: int32, j: int32, value: Any):
+    """Atomically subtract ``value`` onto ``a[i,j]``."""
+    ...
+
+
+@over
+def atomic_sub(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any):
+    """Atomically subtract ``value`` onto ``a[i,j,k]``."""
+    ...
+
+
+@over
+def atomic_sub(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
+    """Atomically subtract ``value`` onto ``a[i,j,k,l]``."""
+    ...
+
+
+@over
+def atomic_sub(a: IndexedFabricArray[Any], i: int32, value: Any):
+    """Atomically subtract ``value`` onto ``a[i]``."""
+    ...
+
+
+@over
+def atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any):
+    """Atomically subtract ``value`` onto ``a[i,j]``."""
+    ...
+
+
+@over
+def atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any):
+    """Atomically subtract ``value`` onto ``a[i,j,k]``."""
+    ...
+
+
+@over
+def atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
+    """Atomically subtract ``value`` onto ``a[i,j,k,l]``."""
+    ...
+
+
+@over
+def atomic_min(a: Array[Any], i: int32, value: Any):
+    """Compute the minimum of ``value`` and ``a[i]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_min(a: Array[Any], i: int32, j: int32, value: Any):
+    """Compute the minimum of ``value`` and ``a[i,j]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_min(a: Array[Any], i: int32, j: int32, k: int32, value: Any):
+    """Compute the minimum of ``value`` and ``a[i,j,k]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_min(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
+    """Compute the minimum of ``value`` and ``a[i,j,k,l]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_min(a: FabricArray[Any], i: int32, value: Any):
+    """Compute the minimum of ``value`` and ``a[i]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_min(a: FabricArray[Any], i: int32, j: int32, value: Any):
+    """Compute the minimum of ``value`` and ``a[i,j]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_min(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any):
+    """Compute the minimum of ``value`` and ``a[i,j,k]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_min(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
+    """Compute the minimum of ``value`` and ``a[i,j,k,l]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_min(a: IndexedFabricArray[Any], i: int32, value: Any):
+    """Compute the minimum of ``value`` and ``a[i]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any):
+    """Compute the minimum of ``value`` and ``a[i,j]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any):
+    """Compute the minimum of ``value`` and ``a[i,j,k]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
+    """Compute the minimum of ``value`` and ``a[i,j,k,l]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_max(a: Array[Any], i: int32, value: Any):
+    """Compute the maximum of ``value`` and ``a[i]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_max(a: Array[Any], i: int32, j: int32, value: Any):
+    """Compute the maximum of ``value`` and ``a[i,j]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_max(a: Array[Any], i: int32, j: int32, k: int32, value: Any):
+    """Compute the maximum of ``value`` and ``a[i,j,k]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_max(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
+    """Compute the maximum of ``value`` and ``a[i,j,k,l]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_max(a: FabricArray[Any], i: int32, value: Any):
+    """Compute the maximum of ``value`` and ``a[i]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_max(a: FabricArray[Any], i: int32, j: int32, value: Any):
+    """Compute the maximum of ``value`` and ``a[i,j]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_max(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any):
+    """Compute the maximum of ``value`` and ``a[i,j,k]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_max(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
+    """Compute the maximum of ``value`` and ``a[i,j,k,l]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_max(a: IndexedFabricArray[Any], i: int32, value: Any):
+    """Compute the maximum of ``value`` and ``a[i]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any):
+    """Compute the maximum of ``value`` and ``a[i,j]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any):
+    """Compute the maximum of ``value`` and ``a[i,j,k]`` and atomically update the array.
+
+    .. note:: The operation is only atomic on a per-component basis for vectors and matrices.
+    """
+    ...
+
+
+@over
+def atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any):
+    """Compute the maximum of ``value`` and ``a[i,j,k,l]`` and atomically update the array.
+
+    .. note:: 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(edge0: Float, edge1: Float, x: Float) -> Float:
+    """Smoothly interpolate between two values ``edge0`` and ``edge1`` using a factor ``x``,
+    and return a result between 0 and 1 using a cubic Hermite interpolation after clamping.
+    """
+    ...
+
+
+@over
+def expect_near(arg1: Float, arg2: Float, tolerance: Float):
+    """Prints an error to stdout if ``arg1`` and ``arg2`` are not closer than tolerance in magnitude"""
+    ...
+
+
+@over
+def expect_near(arg1: vec3f, arg2: vec3f, tolerance: float32):
+    """Prints an error to stdout if any element of ``arg1`` and ``arg2`` 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(x: Scalar, y: Scalar) -> Scalar:
+    """ """
+    ...
+
+
+@over
+def add(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+
+@over
+def add(x: Quaternion[Scalar], y: Quaternion[Scalar]) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+
+@over
+def add(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+
+@over
+def add(x: Transformation[Scalar], y: Transformation[Scalar]) -> Transformation[Scalar]:
+    """ """
+    ...
+
+
+@over
+def sub(x: Scalar, y: Scalar) -> Scalar:
+    """ """
+    ...
+
+
+@over
+def sub(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+
+@over
+def sub(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+
+@over
+def sub(x: Quaternion[Scalar], y: Quaternion[Scalar]) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+
+@over
+def sub(x: Transformation[Scalar], y: Transformation[Scalar]) -> Transformation[Scalar]:
+    """ """
+    ...
+
+
+@over
+def bit_and(x: Int, y: Int) -> Int:
+    """ """
+    ...
+
+
+@over
+def bit_or(x: Int, y: Int) -> Int:
+    """ """
+    ...
+
+
+@over
+def bit_xor(x: Int, y: Int) -> Int:
+    """ """
+    ...
+
+
+@over
+def lshift(x: Int, y: Int) -> Int:
+    """ """
+    ...
+
+
+@over
+def rshift(x: Int, y: Int) -> Int:
+    """ """
+    ...
+
+
+@over
+def invert(x: Int) -> Int:
+    """ """
+    ...
+
+
+@over
+def mul(x: Scalar, y: Scalar) -> Scalar:
+    """ """
+    ...
+
+
+@over
+def mul(x: Vector[Any, Scalar], y: Scalar) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+
+@over
+def mul(x: Scalar, y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+
+@over
+def mul(x: Quaternion[Scalar], y: Scalar) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+
+@over
+def mul(x: Scalar, y: Quaternion[Scalar]) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+
+@over
+def mul(x: Quaternion[Scalar], y: Quaternion[Scalar]) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+
+@over
+def mul(x: Scalar, y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+
+@over
+def mul(x: Matrix[Any, Any, Scalar], y: Scalar) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+
+@over
+def mul(x: Matrix[Any, Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+
+@over
+def mul(x: Vector[Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+
+@over
+def mul(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]):
+    """ """
+    ...
+
+
+@over
+def mul(x: Transformation[Scalar], y: Transformation[Scalar]) -> Transformation[Scalar]:
+    """ """
+    ...
+
+
+@over
+def mul(x: Scalar, y: Transformation[Scalar]) -> Transformation[Scalar]:
+    """ """
+    ...
+
+
+@over
+def mul(x: Transformation[Scalar], y: Scalar) -> Transformation[Scalar]:
+    """ """
+    ...
+
+
+@over
+def mod(x: Scalar, y: Scalar) -> Scalar:
+    """ """
+    ...
+
+
+@over
+def div(x: Scalar, y: Scalar) -> Scalar:
+    """ """
+    ...
+
+
+@over
+def div(x: Vector[Any, Scalar], y: Scalar) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+
+@over
+def div(x: Scalar, y: Vector[Any, Scalar]) -> Vector[Any, Scalar]:
+    """ """
+    ...
+
+
+@over
+def div(x: Matrix[Any, Any, Scalar], y: Scalar) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+
+@over
+def div(x: Scalar, y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]:
+    """ """
+    ...
+
+
+@over
+def div(x: Quaternion[Scalar], y: Scalar) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+
+@over
+def div(x: Scalar, y: Quaternion[Scalar]) -> Quaternion[Scalar]:
+    """ """
+    ...
+
+
+@over
+def floordiv(x: Scalar, y: 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 unot(b: bool) -> bool:
+    """ """
+    ...
+
+
+@over
+def unot(b: int8) -> bool:
+    """ """
+    ...
+
+
+@over
+def unot(b: uint8) -> bool:
+    """ """
+    ...
+
+
+@over
+def unot(b: int16) -> bool:
+    """ """
+    ...
+
+
+@over
+def unot(b: uint16) -> bool:
+    """ """
+    ...
+
+
+@over
+def unot(b: int32) -> bool:
+    """ """
+    ...
+
+
+@over
+def unot(b: uint32) -> bool:
+    """ """
+    ...
+
+
+@over
+def unot(b: int64) -> bool:
+    """ """
+    ...
+
+
+@over
+def unot(b: uint64) -> bool:
+    """ """
+    ...
+
+
+@over
+def unot(a: Array[Any]) -> bool:
+    """ """
+    ...