Kernel Reference

Scalar Types

class warp.int8

class warp.uint8

class warp.int16

class warp.uint16

class warp.int32

class warp.uint32

class warp.int64

class warp.uint64

class warp.float16

class warp.float32

class warp.float64

class warp.bool

Vector Types

class warp.vec2b

class warp.vec2ub

class warp.vec2s

class warp.vec2us

class warp.vec2i

class warp.vec2ui

class warp.vec2l

class warp.vec2ul

class warp.vec2h

class warp.vec2f

class warp.vec2d

class warp.vec3b

class warp.vec3ub

class warp.vec3s

class warp.vec3us

class warp.vec3i

class warp.vec3ui

class warp.vec3l

class warp.vec3ul

class warp.vec3h

class warp.vec3f

class warp.vec3d

class warp.vec4b

class warp.vec4ub

class warp.vec4s

class warp.vec4us

class warp.vec4i

class warp.vec4ui

class warp.vec4l

class warp.vec4ul

class warp.vec4h

class warp.vec4f

class warp.vec4d

class warp.mat22h

class warp.mat22f

class warp.mat22d

class warp.mat33h

class warp.mat33f

class warp.mat33d

class warp.mat44h

class warp.mat44f

class warp.mat44d

class warp.quath

class warp.quatf

class warp.quatd

class warp.transformh

class warp.transformf

class warp.transformd

class warp.spatial_vectorh

class warp.spatial_vectorf

class warp.spatial_vectord

class warp.spatial_matrixh

class warp.spatial_matrixf

class warp.spatial_matrixd

Generic Types

class warp.Int

class warp.Float

class warp.Scalar

class warp.Vector

class warp.Matrix

class warp.Quaternion

class warp.Transformation

class warp.Array

Scalar Math

warp.min(a: Scalar, b: Scalar) → Scalar

Return the minimum of two scalars.

warp.min(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) → Vector[Any, Scalar]

Return the element-wise minimum of two vectors.

warp.min(a: Vector[Any, Scalar]) → Scalar

Return the minimum element of a vector a.

warp.max(a: Scalar, b: Scalar) → Scalar

Return the maximum of two scalars.

warp.max(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) → Vector[Any, Scalar]

Return the element-wise maximum of two vectors.

warp.max(a: Vector[Any, Scalar]) → Scalar

Return the maximum element of a vector a.

warp.clamp(x: Scalar, low: Scalar, high: Scalar) → Scalar

Clamp the value of x to the range [low, high].

warp.abs(x: Scalar) → Scalar

Return the absolute value of x.

warp.abs(x: Vector[Any, Scalar]) → Vector[Any, Scalar]

Return the absolute values of the elements of x.

warp.sign(x: Scalar) → Scalar

Return -1 if x < 0, return 1 otherwise.

warp.sign(x: Vector[Any, Scalar]) → Scalar

Return -1 for the negative elements of x, and 1 otherwise.

warp.step(x: Scalar) → Scalar

Return 1.0 if x < 0.0, return 0.0 otherwise.

warp.nonzero(x: Scalar) → Scalar

Return 1.0 if x is not equal to zero, return 0.0 otherwise.

warp.sin(x: Float) → Float

Return the sine of x in radians.

warp.cos(x: Float) → Float

Return the cosine of x in radians.

warp.acos(x: Float) → Float

Return arccos of x in radians. Inputs are automatically clamped to [-1.0, 1.0].

warp.asin(x: Float) → Float

Return arcsin of x in radians. Inputs are automatically clamped to [-1.0, 1.0].

warp.sqrt(x: Float) → Float

Return the square root of x, where x is positive.

warp.cbrt(x: Float) → Float

Return the cube root of x.

warp.tan(x: Float) → Float

Return the tangent of x in radians.

warp.atan(x: Float) → Float

Return the arctangent of x in radians.

warp.atan2(y: Float, x: Float) → Float

Return the 2-argument arctangent, atan2, of the point (x, y) in radians.

warp.sinh(x: Float) → Float

Return the sinh of x.

warp.cosh(x: Float) → Float

Return the cosh of x.

warp.tanh(x: Float) → Float

Return the tanh of x.

warp.degrees(x: Float) → Float

Convert x from radians into degrees.

warp.radians(x: Float) → Float

Convert x from degrees into radians.

warp.log(x: Float) → Float

Return the natural logarithm (base-e) of x, where x is positive.

warp.log2(x: Float) → Float

Return the binary logarithm (base-2) of x, where x is positive.

warp.log10(x: Float) → Float

Return the common logarithm (base-10) of x, where x is positive.

warp.exp(x: Float) → Float

Return the value of the exponential function \(e^x\).

warp.pow(x: Float, y: Float) → Float

Return the result of x raised to power of y.

warp.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 warp.rint(). Differs from numpy.round(), which behaves the same way as numpy.rint().

warp.rint(x: Float) → Float

Return the nearest integer value to x, rounding halfway cases to nearest even integer.

It is generally faster than warp.round(). Equivalent to numpy.rint().

warp.trunc(x: Float) → Float

Return the nearest integer that is closer to zero than x.

In other words, it discards the fractional part of x. It is similar to casting float(int(a)), but preserves the negative sign when x is in the range [-0.0, -1.0). Equivalent to numpy.trunc() and numpy.fix().

warp.floor(x: Float) → Float

Return the largest integer that is less than or equal to x.

warp.ceil(x: Float) → Float

Return the smallest integer that is greater than or equal to x.

warp.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).

warp.isfinite(a: Scalar) → bool

Return True if a is a finite number, otherwise return False.

warp.isfinite(a: Vector[Any, Scalar]) → bool

Return True if all elements of the vector a are finite, otherwise return False.

warp.isfinite(a: Quaternion[Scalar]) → bool

Return True if all elements of the quaternion a are finite, otherwise return False.

warp.isfinite(a: Matrix[Any, Any, Scalar]) → bool

Return True if all elements of the matrix a are finite, otherwise return False.

warp.isnan(a: Scalar) → bool

Return True if a is NaN, otherwise return False.

warp.isnan(a: Vector[Any, Scalar]) → bool

Return True if any element of the vector a is NaN, otherwise return False.

warp.isnan(a: Quaternion[Scalar]) → bool

Return True if any element of the quaternion a is NaN, otherwise return False.

warp.isnan(a: Matrix[Any, Any, Scalar]) → bool

Return True if any element of the matrix a is NaN, otherwise return False.

warp.isinf(a: Scalar) → bool

Return True if a is positive or negative infinity, otherwise return False.

warp.isinf(a: Vector[Any, Scalar]) → bool

Return True if any element of the vector a is positive or negative infinity, otherwise return False.

warp.isinf(a: Quaternion[Scalar]) → bool

Return True if any element of the quaternion a is positive or negative infinity, otherwise return False.

warp.isinf(a: Matrix[Any, Any, Scalar]) → bool

Return True if any element of the matrix a is positive or negative infinity, otherwise return False.

Vector Math

warp.dot(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) → Scalar

Compute the dot product between two vectors.

warp.dot(a: Quaternion[Float], b: Quaternion[Float]) → Float

Compute the dot product between two quaternions.

warp.ddot(a: Matrix[Any, Any, Scalar], b: Matrix[Any, Any, Scalar]) → Scalar

Compute the double dot product between two matrices.

warp.argmin(a: Vector[Any, Scalar]) → uint32

Return the index of the minimum element of a vector a. [1]

warp.argmax(a: Vector[Any, Scalar]) → uint32

Return the index of the maximum element of a vector a. [1]

warp.outer(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) → Matrix[Any, Any, Scalar]

Compute the outer product a*b^T for two vectors.

warp.cross(a: Vector[3, Scalar], b: Vector[3, Scalar]) → Vector[3, Scalar]

Compute the cross product of two 3D vectors.

warp.skew(vec: Vector[3, Scalar]) → Matrix[3, 3, Scalar]

Compute the skew-symmetric 3x3 matrix for a 3D vector vec.

warp.length(a: Vector[Any, Float]) → Float

Compute the length of a floating-point vector a.

warp.length(a: Quaternion[Float]) → Float

Compute the length of a quaternion a.

warp.length_sq(a: Vector[Any, Scalar]) → Scalar

Compute the squared length of a vector a.

warp.length_sq(a: Quaternion[Scalar]) → Scalar

Compute the squared length of a quaternion a.

warp.normalize(a: Vector[Any, Float]) → Vector[Any, Float]

Compute the normalized value of a. If length(a) is 0 then the zero vector is returned.

warp.normalize(a: Quaternion[Float]) → Quaternion[Float]

Compute the normalized value of a. If length(a) is 0, then the zero quaternion is returned.

warp.transpose(a: Matrix[Any, Any, Scalar]) → Matrix[Any, Any, Scalar]

Return the transpose of the matrix a.

warp.inverse(a: Matrix[2, 2, Float]) → Matrix[Any, Any, Float]

Return the inverse of a 2x2 matrix a.

warp.inverse(a: Matrix[3, 3, Float]) → Matrix[Any, Any, Float]

Return the inverse of a 3x3 matrix a.

warp.inverse(a: Matrix[4, 4, Float]) → Matrix[Any, Any, Float]

Return the inverse of a 4x4 matrix a.

warp.determinant(a: Matrix[2, 2, Float]) → Float

Return the determinant of a 2x2 matrix a.

warp.determinant(a: Matrix[3, 3, Float]) → Float

Return the determinant of a 3x3 matrix a.

warp.determinant(a: Matrix[4, 4, Float]) → Float

Return the determinant of a 4x4 matrix a.

warp.trace(a: Matrix[Any, Any, Scalar]) → Scalar

Return the trace of the matrix a.

warp.diag(vec: Vector[Any, Scalar]) → Matrix[Any, Any, Scalar]

Returns a matrix with the components of the vector vec on the diagonal.

warp.get_diag(mat: Matrix[Any, Any, Scalar]) → Vector[Any, Scalar]

Returns a vector containing the diagonal elements of the square matrix mat.

warp.cw_mul(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) → Vector[Any, Scalar]

Component-wise multiplication of two vectors.

warp.cw_mul(a: Matrix[Any, Any, Scalar], b: Matrix[Any, Any, Scalar]) → Matrix[Any, Any, Scalar]

Component-wise multiplication of two matrices.

warp.cw_div(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) → Vector[Any, Scalar]

Component-wise division of two vectors.

warp.cw_div(a: Matrix[Any, Any, Scalar], b: Matrix[Any, Any, Scalar]) → Matrix[Any, Any, Scalar]

Component-wise division of two matrices.

warp.vector(*args: Scalar, length: int32, dtype: Scalar) → Vector[Any, Scalar]

Construct a vector of given length and dtype.

warp.matrix(pos: Vector[3, Float], rot: Quaternion[Float], scale: Vector[3, Float], dtype: Float) → Matrix[4, 4, Float]

Construct a 4x4 transformation matrix that applies the transformations as Translation(pos)*Rotation(rot)*Scaling(scale) when applied to column vectors, i.e.: y = (TRS)*x

warp.matrix(*args: Scalar, shape: Tuple[int, int], dtype: Scalar) → Matrix[Any, Any, Scalar]

Construct a matrix. If the positional arg_types are not given, then matrix will be zero-initialized.

warp.identity(n: int32, dtype: Scalar) → Matrix[Any, Any, Scalar]

Create an identity matrix with shape=(n,n) with the type given by dtype.

warp.svd3(A: Matrix[3, 3, Float], U: Matrix[3, 3, Float], sigma: Vector[3, Float], V: Matrix[3, 3, Scalar]) → None

Compute the SVD of a 3x3 matrix A. The singular values are returned in sigma, while the left and right basis vectors are returned in U and V.

warp.qr3(A: Matrix[3, 3, Float], Q: Matrix[3, 3, Float], R: Matrix[3, 3, Float]) → None

Compute the QR decomposition of a 3x3 matrix A. The orthogonal matrix is returned in Q, while the upper triangular matrix is returned in R.

warp.eig3(A: Matrix[3, 3, Float], Q: Matrix[3, 3, Float], d: Vector[3, Float]) → None

Compute the eigendecomposition of a 3x3 matrix A. The eigenvectors are returned as the columns of Q, while the corresponding eigenvalues are returned in d.

Quaternion Math

warp.quaternion(dtype: Float) → Quaternion[Float]

Construct a zero-initialized quaternion. Quaternions are laid out as [ix, iy, iz, r], where ix, iy, iz are the imaginary part, and r the real part.

warp.quaternion(x: Float, y: Float, z: Float, w: Float) → Quaternion[Float]

Create a quaternion using the supplied components (type inferred from component type).

warp.quaternion(ijk: Vector[3, Float], real: Float, dtype: Float) → Quaternion[Float]

Create a quaternion using the supplied vector/scalar (type inferred from scalar type).

warp.quaternion(quat: Quaternion[Float], dtype: Float) → Quaternion[Float]

Construct a quaternion of type dtype from another quaternion of a different dtype.

warp.quat_identity(dtype: Float) → quatf

Construct an identity quaternion with zero imaginary part and real part of 1.0

warp.quat_from_axis_angle(axis: Vector[3, Float], angle: Float) → Quaternion[Float]

Construct a quaternion representing a rotation of angle radians around the given axis.

warp.quat_to_axis_angle(quat: Quaternion[Float], axis: Vector[3, Float], angle: Float) → None

Extract the rotation axis and angle radians a quaternion represents.

warp.quat_from_matrix(mat: Matrix[3, 3, Float]) → Quaternion[Float]

Construct a quaternion from a 3x3 matrix.

warp.quat_rpy(roll: Float, pitch: Float, yaw: Float) → Quaternion[Float]

Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians.

warp.quat_inverse(quat: Quaternion[Float]) → Quaternion[Float]

Compute quaternion conjugate.

warp.quat_rotate(quat: Quaternion[Float], vec: Vector[3, Float]) → Vector[3, Float]

Rotate a vector by a quaternion.

warp.quat_rotate_inv(quat: Quaternion[Float], vec: Vector[3, Float]) → Vector[3, Float]

Rotate a vector by the inverse of a quaternion.

warp.quat_slerp(a: Quaternion[Float], b: Quaternion[Float], t: Float) → Quaternion[Float]

Linearly interpolate between two quaternions.

warp.quat_to_matrix(quat: Quaternion[Float]) → Matrix[3, 3, Float]

Convert a quaternion to a 3x3 rotation matrix.

Transformations

warp.transformation(pos: Vector[3, Float], rot: Quaternion[Float], dtype: Float) → Transformation[Float]

Construct a rigid-body transformation with translation part pos and rotation rot.

warp.transform_identity(dtype: Float) → transformf

Construct an identity transform with zero translation and identity rotation.

warp.transform_get_translation(xform: Transformation[Float]) → Vector[3, Float]

Return the translational part of a transform xform.

warp.transform_get_rotation(xform: Transformation[Float]) → Quaternion[Float]

Return the rotational part of a transform xform.

warp.transform_multiply(a: Transformation[Float], b: Transformation[Float]) → Transformation[Float]

Multiply two rigid body transformations together.

warp.transform_point(xform: Transformation[Float], point: Vector[3, Float]) → Vector[3, Float]

Apply the transform to a point point treating the homogeneous coordinate as w=1 (translation and rotation).

warp.transform_point(mat: Matrix[4, 4, Float], point: Vector[3, Float]) → Vector[3, Float]

Apply the transform to a point point treating the homogeneous coordinate as w=1.

The transformation is applied treating point as a column vector, e.g.: y = mat*point.

This is in contrast to some libraries, notably USD, which applies transforms to row vectors, y^T = point^T*mat^T. If the transform is coming from a library that uses row-vectors, then users should transpose the transformation matrix before calling this method.

warp.transform_vector(xform: Transformation[Float], vec: Vector[3, Float]) → Vector[3, Float]

Apply the transform to a vector vec treating the homogeneous coordinate as w=0 (rotation only).

warp.transform_vector(mat: Matrix[4, 4, Float], vec: Vector[3, Float]) → Vector[3, Float]

Apply the transform to a vector vec treating the homogeneous coordinate as w=0.

The transformation is applied treating vec as a column vector, e.g.: y = mat*vec.

This is in contrast to some libraries, notably USD, which applies transforms to row vectors, y^T = vec^T*mat^T. If the transform is coming from a library that uses row-vectors, then users should transpose the transformation matrix before calling this method.

warp.transform_inverse(xform: Transformation[Float]) → Transformation[Float]

Compute the inverse of the transformation xform.

Spatial Math

warp.spatial_vector(dtype: Float) → Vector[6, Float]

Zero-initialize a 6D screw vector.

warp.spatial_vector(w: Vector[3, Float], v: Vector[3, Float], dtype: Float) → Vector[6, Float]

Construct a 6D screw vector from two 3D vectors.

warp.spatial_vector(wx: Float, wy: Float, wz: Float, vx: Float, vy: Float, vz: Float, dtype: Float) → Vector[6, Float]

Construct a 6D screw vector from six values.

warp.spatial_adjoint(r: Matrix[3, 3, Float], s: Matrix[3, 3, Float]) → Matrix[6, 6, Float]

Construct a 6x6 spatial inertial matrix from two 3x3 diagonal blocks.

warp.spatial_dot(a: Vector[6, Float], b: Vector[6, Float]) → Float

Compute the dot product of two 6D screw vectors.

warp.spatial_cross(a: Vector[6, Float], b: Vector[6, Float]) → Vector[6, Float]

Compute the cross product of two 6D screw vectors.

warp.spatial_cross_dual(a: Vector[6, Float], b: Vector[6, Float]) → Vector[6, Float]

Compute the dual cross product of two 6D screw vectors.

warp.spatial_top(svec: Vector[6, Float]) → Vector[3, Float]

Return the top (first) part of a 6D screw vector.

warp.spatial_bottom(svec: Vector[6, Float]) → Vector[3, Float]

Return the bottom (second) part of a 6D screw vector.

warp.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]) → None

warp.spatial_mass(I_s: Array[Matrix[6, 6, Float]], joint_start: int32, joint_count: int32, M_start: int32, M: Array[Float]) → None

Utility

warp.mlp(weights: Array[float32], bias: Array[float32], activation: Callable, index: int32, x: Array[float32], out: Array[float32]) → None

Evaluate a multi-layer perceptron (MLP) layer in the form: out = act(weights*x + bias).

Parameters:

• weights – A layer’s network weights with dimensions (m, n).

• bias – An array with dimensions (n).

• activation – A wp.func function that takes a single scalar float as input and returns a scalar float as output

• index – The batch item to process, typically each thread will process one item in the batch, in which case index should be wp.tid()

• x – The feature matrix with dimensions (n, b)

• 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).

warp.printf(fmt: str, *args: Any) → None

Allows printing formatted strings using C-style format specifiers.

warp.print(value: Any) → None

Print variable to stdout

warp.breakpoint() → None

Debugger breakpoint

warp.tid() → int

Return the current thread index for a 1D kernel launch.

Note that this is the global index of the thread in the range [0, dim) where dim is the parameter passed to kernel launch.

This function may not be called from user-defined Warp functions.

warp.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.

warp.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.

warp.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.

warp.select(cond: bool, value_if_false: Any, value_if_true: Any) → Any

Select between two arguments, if cond is False then return value_if_false, otherwise return value_if_true

warp.select(cond: int8, value_if_false: Any, value_if_true: Any) → Any

Select between two arguments, if cond is False then return value_if_false, otherwise return value_if_true

warp.select(cond: uint8, value_if_false: Any, value_if_true: Any) → Any

Select between two arguments, if cond is False then return value_if_false, otherwise return value_if_true

warp.select(cond: int16, value_if_false: Any, value_if_true: Any) → Any

Select between two arguments, if cond is False then return value_if_false, otherwise return value_if_true

warp.select(cond: uint16, value_if_false: Any, value_if_true: Any) → Any

Select between two arguments, if cond is False then return value_if_false, otherwise return value_if_true

warp.select(cond: int32, value_if_false: Any, value_if_true: Any) → Any

Select between two arguments, if cond is False then return value_if_false, otherwise return value_if_true

warp.select(cond: uint32, value_if_false: Any, value_if_true: Any) → Any

Select between two arguments, if cond is False then return value_if_false, otherwise return value_if_true

warp.select(cond: int64, value_if_false: Any, value_if_true: Any) → Any

Select between two arguments, if cond is False then return value_if_false, otherwise return value_if_true

warp.select(cond: uint64, value_if_false: Any, value_if_true: Any) → Any

Select between two arguments, if cond is False then return value_if_false, otherwise return value_if_true

warp.select(arr: Array[Any], value_if_false: Any, value_if_true: Any) → Any

Select between two arguments, if arr is null then return value_if_false, otherwise return value_if_true

warp.atomic_add(arr: Array[Any], i: Int, value: Any) → Any

Atomically add value onto arr[i] and return the old value.

warp.atomic_add(arr: Array[Any], i: Int, j: Int, value: Any) → Any

Atomically add value onto arr[i,j] and return the old value.

warp.atomic_add(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) → Any

Atomically add value onto arr[i,j,k] and return the old value.

warp.atomic_add(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) → Any

Atomically add value onto arr[i,j,k,l] and return the old value.

warp.atomic_add(arr: FabricArray[Any], i: Int, value: Any) → Any

Atomically add value onto arr[i] and return the old value.

warp.atomic_add(arr: FabricArray[Any], i: Int, j: Int, value: Any) → Any

Atomically add value onto arr[i,j] and return the old value.

warp.atomic_add(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) → Any

Atomically add value onto arr[i,j,k] and return the old value.

warp.atomic_add(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) → Any

Atomically add value onto arr[i,j,k,l] and return the old value.

warp.atomic_add(arr: IndexedFabricArray[Any], i: Int, value: Any) → Any

Atomically add value onto arr[i] and return the old value.

warp.atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) → Any

Atomically add value onto arr[i,j] and return the old value.

warp.atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) → Any

Atomically add value onto arr[i,j,k] and return the old value.

warp.atomic_add(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) → Any

Atomically add value onto arr[i,j,k,l] and return the old value.

warp.atomic_sub(arr: Array[Any], i: Int, value: Any) → Any

Atomically subtract value onto arr[i] and return the old value.

warp.atomic_sub(arr: Array[Any], i: Int, j: Int, value: Any) → Any

Atomically subtract value onto arr[i,j] and return the old value.

warp.atomic_sub(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) → Any

Atomically subtract value onto arr[i,j,k] and return the old value.

warp.atomic_sub(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) → Any

Atomically subtract value onto arr[i,j,k,l] and return the old value.

warp.atomic_sub(arr: FabricArray[Any], i: Int, value: Any) → Any

Atomically subtract value onto arr[i] and return the old value.

warp.atomic_sub(arr: FabricArray[Any], i: Int, j: Int, value: Any) → Any

Atomically subtract value onto arr[i,j] and return the old value.

warp.atomic_sub(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) → Any

Atomically subtract value onto arr[i,j,k] and return the old value.

warp.atomic_sub(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) → Any

Atomically subtract value onto arr[i,j,k,l] and return the old value.

warp.atomic_sub(arr: IndexedFabricArray[Any], i: Int, value: Any) → Any

Atomically subtract value onto arr[i] and return the old value.

warp.atomic_sub(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) → Any

Atomically subtract value onto arr[i,j] and return the old value.

warp.atomic_sub(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) → Any

Atomically subtract value onto arr[i,j,k] and return the old value.

warp.atomic_sub(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) → Any

Atomically subtract value onto arr[i,j,k,l] and return the old value.

warp.atomic_min(arr: Array[Any], i: Int, value: Any) → Any

Compute the minimum of value and arr[i], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_min(arr: Array[Any], i: Int, j: Int, value: Any) → Any

Compute the minimum of value and arr[i,j], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_min(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) → Any

Compute the minimum of value and arr[i,j,k], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_min(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) → Any

Compute the minimum of value and arr[i,j,k,l], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_min(arr: FabricArray[Any], i: Int, value: Any) → Any

Compute the minimum of value and arr[i], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_min(arr: FabricArray[Any], i: Int, j: Int, value: Any) → Any

Compute the minimum of value and arr[i,j], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_min(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) → Any

Compute the minimum of value and arr[i,j,k], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_min(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) → Any

Compute the minimum of value and arr[i,j,k,l], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_min(arr: IndexedFabricArray[Any], i: Int, value: Any) → Any

Compute the minimum of value and arr[i], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_min(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) → Any

Compute the minimum of value and arr[i,j], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_min(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) → Any

Compute the minimum of value and arr[i,j,k], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_min(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) → Any

Compute the minimum of value and arr[i,j,k,l], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_max(arr: Array[Any], i: Int, value: Any) → Any

Compute the maximum of value and arr[i], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_max(arr: Array[Any], i: Int, j: Int, value: Any) → Any

Compute the maximum of value and arr[i,j], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_max(arr: Array[Any], i: Int, j: Int, k: Int, value: Any) → Any

Compute the maximum of value and arr[i,j,k], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_max(arr: Array[Any], i: Int, j: Int, k: Int, l: Int, value: Any) → Any

Compute the maximum of value and arr[i,j,k,l], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_max(arr: FabricArray[Any], i: Int, value: Any) → Any

Compute the maximum of value and arr[i], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_max(arr: FabricArray[Any], i: Int, j: Int, value: Any) → Any

Compute the maximum of value and arr[i,j], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_max(arr: FabricArray[Any], i: Int, j: Int, k: Int, value: Any) → Any

Compute the maximum of value and arr[i,j,k], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_max(arr: FabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) → Any

Compute the maximum of value and arr[i,j,k,l], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_max(arr: IndexedFabricArray[Any], i: Int, value: Any) → Any

Compute the maximum of value and arr[i], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_max(arr: IndexedFabricArray[Any], i: Int, j: Int, value: Any) → Any

Compute the maximum of value and arr[i,j], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_max(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, value: Any) → Any

Compute the maximum of value and arr[i,j,k], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.atomic_max(arr: IndexedFabricArray[Any], i: Int, j: Int, k: Int, l: Int, value: Any) → Any

Compute the maximum of value and arr[i,j,k,l], atomically update the array, and return the old value.

The operation is only atomic on a per-component basis for vectors and matrices.

warp.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

warp.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

warp.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

warp.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

warp.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

warp.smoothstep(a: Float, b: Float, x: Float) → Float

Smoothly interpolate between two values a and b using a factor x, and return a result between 0 and 1 using a cubic Hermite interpolation after clamping.

warp.expect_near(a: Float, b: Float, tolerance: Float) → None

Prints an error to stdout if a and b are not closer than tolerance in magnitude

warp.expect_near(a: vec3f, b: vec3f, tolerance: float32) → None

Prints an error to stdout if any element of a and b are not closer than tolerance in magnitude

Geometry

warp.BvhQuery

alias of bvh_query_t

warp.bvh_query_aabb(id: uint64, low: vec3f, high: 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.

Parameters:

• id – The BVH identifier

• low – The lower bound of the bounding box in BVH space

• high – The upper bound of the bounding box in BVH space

warp.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.

Parameters:

• id – The BVH identifier

• start – The start of the ray in BVH space

• dir – The direction of the ray in BVH space

warp.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.

warp.MeshQueryPoint

alias of mesh_query_point_t

warp.mesh_query_point(id: uint64, point: vec3f, max_dist: float32) → mesh_query_point_t

Computes the closest point on the 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.

Parameters:

• id – The mesh identifier

• point – The point in space to query

• max_dist – Mesh faces above this distance will not be considered by the query

warp.mesh_query_point_no_sign(id: uint64, point: vec3f, max_dist: float32) → mesh_query_point_t

Computes the closest 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) which makes it faster than other point query methods.

Parameters:

• id – The mesh identifier

• point – The point in space to query

• max_dist – Mesh faces above this distance will not be considered by the query

warp.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).

Parameters:

• id – The mesh identifier

• point – The point in space to query

• min_dist – Mesh faces below this distance will not be considered by the query

warp.mesh_query_point_sign_normal(id: uint64, point: vec3f, max_dist: float32, epsilon: float32) → mesh_query_point_t

Computes the closest point on the 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.

Parameters:

• id – The mesh identifier

• point – The point in space to query

• max_dist – Mesh faces above this distance will not be considered by the query

• 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

warp.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 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 Mesh object must be constructed with support_winding_number=True for this method to return correct results.

Parameters:

• id – The mesh identifier

• point – The point in space to query

• max_dist – Mesh faces above this distance will not be considered by the query

• accuracy – Accuracy for computing the winding number with fast winding number method utilizing second-order dipole approximation, default 2.0

• threshold – The threshold of the winding number to be considered inside, default 0.5

warp.MeshQueryRay

alias of mesh_query_ray_t

warp.mesh_query_ray(id: uint64, start: vec3f, dir: vec3f, max_t: float32) → mesh_query_ray_t

Computes the closest ray hit on the Mesh with identifier id.

Parameters:

• id – The mesh identifier

• start – The start point of the ray

• dir – The ray direction (should be normalized)

• max_t – The maximum distance along the ray to check for intersections

warp.MeshQueryAABB

alias of mesh_query_aabb_t

warp.mesh_query_aabb(id: uint64, low: vec3f, high: vec3f) → mesh_query_aabb_t

Construct an axis-aligned bounding box query against a Mesh.

This query can be used to iterate over all triangles inside a volume.

Parameters:

• id – The mesh identifier

• low – The lower bound of the bounding box in mesh space

• high – The upper bound of the bounding box in mesh space

warp.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.

warp.mesh_eval_position(id: uint64, face: int32, bary_u: float32, bary_v: float32) → vec3f

Evaluates the position on the Mesh given a face index and barycentric coordinates.

warp.mesh_eval_velocity(id: uint64, face: int32, bary_u: float32, bary_v: float32) → vec3f

Evaluates the velocity on the Mesh given a face index and barycentric coordinates.

warp.HashGridQuery

alias of hash_grid_query_t

warp.hash_grid_query(id: uint64, point: vec3f, max_dist: float32) → hash_grid_query_t

Construct a point query against a HashGrid.

This query can be used to iterate over all neighboring point within a fixed radius from the query point.

warp.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.

warp.hash_grid_point_id(id: uint64, index: int32) → int

Return the index of a point in the HashGrid.

This can be used to reorder threads such that grid traversal occurs in a spatially coherent order.

Returns -1 if the HashGrid has not been reserved.

warp.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.

warp.mesh_get(id: uint64) → Mesh

Retrieves the mesh given its index. [1]

warp.mesh_eval_face_normal(id: uint64, face: int32) → vec3f

Evaluates the face normal the mesh given a face index.

warp.mesh_get_point(id: uint64, index: int32) → vec3f

Returns the point of the mesh given a index.

warp.mesh_get_velocity(id: uint64, index: int32) → vec3f

Returns the velocity of the mesh given a index.

warp.mesh_get_index(id: uint64, index: int32) → int

Returns the point-index of the mesh given a face-vertex index.

warp.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.

Parameters:

• p1 – First point of first edge

• q1 – Second point of first edge

• p2 – First point of second edge

• q2 – Second point of second edge

• epsilon – Zero tolerance for determining if points in an edge are degenerate.

• 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.

Volumes

warp.volume_sample(id: uint64, uvw: vec3f, sampling_mode: int32, dtype: Any) → Any

Sample the volume of type dtype given by id at the volume local-space point uvw.

Interpolation should be warp.Volume.CLOSEST or wp.Volume.LINEAR.

warp.volume_sample_grad(id: uint64, uvw: vec3f, sampling_mode: int32, grad: Any, dtype: Any) → Any

Sample the volume given by id and its gradient at the volume local-space point uvw.

Interpolation should be warp.Volume.CLOSEST or wp.Volume.LINEAR.

warp.volume_lookup(id: uint64, i: int32, j: int32, k: int32, dtype: Any) → Any

Returns the value of voxel with coordinates i, j, k for a volume of type type dtype.

If the voxel at this index does not exist, this function returns the background value.

warp.volume_store(id: uint64, i: int32, j: int32, k: int32, value: Any) → None

Store value at the voxel with coordinates i, j, k.

warp.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 warp.Volume.CLOSEST or wp.Volume.LINEAR.

warp.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 warp.Volume.CLOSEST or wp.Volume.LINEAR.

warp.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

warp.volume_store_f(id: uint64, i: int32, j: int32, k: int32, value: float32) → None

Store value at the voxel with coordinates i, j, k.

warp.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 warp.Volume.CLOSEST or wp.Volume.LINEAR.

warp.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.

warp.volume_store_v(id: uint64, i: int32, j: int32, k: int32, value: vec3f) → None

Store value at the voxel with coordinates i, j, k.

warp.volume_sample_i(id: uint64, uvw: vec3f) → int

Sample the int32 volume given by id at the volume local-space point uvw.

warp.volume_lookup_i(id: uint64, i: int32, j: int32, k: int32) → int

Returns the int32 value of voxel with coordinates i, j, k.

If the voxel at this index does not exist, this function returns the background value.

warp.volume_store_i(id: uint64, i: int32, j: int32, k: int32, value: int32) → None

Store value at the voxel with coordinates i, j, k.

warp.volume_sample_index(id: uint64, uvw: vec3f, sampling_mode: int32, voxel_data: Array[Any], background: Any) → Any

Sample the volume given by id at the volume local-space point uvw.

Values for allocated voxels are read from the voxel_data array, and background is used as the value of non-existing voxels. Interpolation should be warp.Volume.CLOSEST or wp.Volume.LINEAR. This function is available for both index grids and classical volumes.

warp.volume_sample_grad_index(id: uint64, uvw: vec3f, sampling_mode: int32, voxel_data: Array[Any], background: Any, grad: Any) → Any

Sample the volume given by id and its gradient at the volume local-space point uvw.

Values for allocated voxels are read from the voxel_data array, and background is used as the value of non-existing voxels. Interpolation should be warp.Volume.CLOSEST or wp.Volume.LINEAR. This function is available for both index grids and classical volumes.

warp.volume_lookup_index(id: uint64, i: int32, j: int32, k: int32) → int32

Returns the index associated to the voxel with coordinates i, j, k.

If the voxel at this index does not exist, this function returns -1. This function is available for both index grids and classical volumes.

warp.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.

warp.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.

warp.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.

warp.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.

Random

warp.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.

warp.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)

warp.randi(state: uint32) → int

Return a random integer in the range [0, 2^32).

warp.randi(state: uint32, low: int32, high: int32) → int

Return a random integer between [low, high).

warp.randf(state: uint32) → float

Return a random float between [0.0, 1.0).

warp.randf(state: uint32, low: float32, high: float32) → float

Return a random float between [low, high).

warp.randn(state: uint32) → float

Sample a normal distribution.

warp.sample_cdf(state: uint32, cdf: Array[float32]) → int

Inverse-transform sample a cumulative distribution function.

warp.sample_triangle(state: uint32) → vec2f

Uniformly sample a triangle. Returns sample barycentric coordinates.

warp.sample_unit_ring(state: uint32) → vec2f

Uniformly sample a ring in the xy plane.

warp.sample_unit_disk(state: uint32) → vec2f

Uniformly sample a disk in the xy plane.

warp.sample_unit_sphere_surface(state: uint32) → vec3f

Uniformly sample a unit sphere surface.

warp.sample_unit_sphere(state: uint32) → vec3f

Uniformly sample a unit sphere.

warp.sample_unit_hemisphere_surface(state: uint32) → vec3f

Uniformly sample a unit hemisphere surface.

warp.sample_unit_hemisphere(state: uint32) → vec3f

Uniformly sample a unit hemisphere.

warp.sample_unit_square(state: uint32) → vec2f

Uniformly sample a unit square.

warp.sample_unit_cube(state: uint32) → vec3f

Uniformly sample a unit cube.

warp.poisson(state: uint32, lam: float32) → uint32

Generate a random sample from a Poisson distribution.

Parameters:

• state – RNG state

• lam – The expected value of the distribution

warp.noise(state: uint32, x: float32) → float

Non-periodic Perlin-style noise in 1D.

warp.noise(state: uint32, xy: vec2f) → float

Non-periodic Perlin-style noise in 2D.

warp.noise(state: uint32, xyz: vec3f) → float

Non-periodic Perlin-style noise in 3D.

warp.noise(state: uint32, xyzt: vec4f) → float

Non-periodic Perlin-style noise in 4D.

warp.pnoise(state: uint32, x: float32, px: int32) → float

Periodic Perlin-style noise in 1D.

warp.pnoise(state: uint32, xy: vec2f, px: int32, py: int32) → float

Periodic Perlin-style noise in 2D.

warp.pnoise(state: uint32, xyz: vec3f, px: int32, py: int32, pz: int32) → float

Periodic Perlin-style noise in 3D.

warp.pnoise(state: uint32, xyzt: vec4f, px: int32, py: int32, pz: int32, pt: int32) → float

Periodic Perlin-style noise in 4D.

warp.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. [1]

warp.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. [1]

warp.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. [1]

Other

warp.lower_bound(arr: Array[Scalar], value: Scalar) → int

Search a sorted array arr for the closest element greater than or equal to value.

warp.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.

warp.bit_and(a: Int, b: Int) → Int

warp.bit_or(a: Int, b: Int) → Int

warp.bit_xor(a: Int, b: Int) → Int

warp.lshift(a: Int, b: Int) → Int

warp.rshift(a: Int, b: Int) → Int

warp.invert(a: Int) → Int

Operators

warp.add(a: Scalar, b: Scalar) → Scalar

warp.add(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) → Vector[Any, Scalar]

warp.add(a: Quaternion[Scalar], b: Quaternion[Scalar]) → Quaternion[Scalar]

warp.add(a: Matrix[Any, Any, Scalar], b: Matrix[Any, Any, Scalar]) → Matrix[Any, Any, Scalar]

warp.add(a: Transformation[Scalar], b: Transformation[Scalar]) → Transformation[Scalar]

warp.sub(a: Scalar, b: Scalar) → Scalar

warp.sub(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) → Vector[Any, Scalar]

warp.sub(a: Matrix[Any, Any, Scalar], b: Matrix[Any, Any, Scalar]) → Matrix[Any, Any, Scalar]

warp.sub(a: Quaternion[Scalar], b: Quaternion[Scalar]) → Quaternion[Scalar]

warp.sub(a: Transformation[Scalar], b: Transformation[Scalar]) → Transformation[Scalar]

warp.mul(a: Scalar, b: Scalar) → Scalar

warp.mul(a: Vector[Any, Scalar], b: Scalar) → Vector[Any, Scalar]

warp.mul(a: Scalar, b: Vector[Any, Scalar]) → Vector[Any, Scalar]

warp.mul(a: Quaternion[Scalar], b: Scalar) → Quaternion[Scalar]

warp.mul(a: Scalar, b: Quaternion[Scalar]) → Quaternion[Scalar]

warp.mul(a: Quaternion[Scalar], b: Quaternion[Scalar]) → Quaternion[Scalar]

warp.mul(a: Scalar, b: Matrix[Any, Any, Scalar]) → Matrix[Any, Any, Scalar]

warp.mul(a: Matrix[Any, Any, Scalar], b: Scalar) → Matrix[Any, Any, Scalar]

warp.mul(a: Matrix[Any, Any, Scalar], b: Vector[Any, Scalar]) → Vector[Any, Scalar]

warp.mul(a: Vector[Any, Scalar], b: Matrix[Any, Any, Scalar]) → Vector[Any, Scalar]

warp.mul(a: Matrix[Any, Any, Scalar], b: Matrix[Any, Any, Scalar]) → Matrix[Any, Any, Scalar]

warp.mul(a: Transformation[Scalar], b: Transformation[Scalar]) → Transformation[Scalar]

warp.mul(a: Scalar, b: Transformation[Scalar]) → Transformation[Scalar]

warp.mul(a: Transformation[Scalar], b: Scalar) → Transformation[Scalar]

warp.mod(a: Scalar, b: Scalar) → Scalar

Modulo operation using truncated division.

warp.mod(a: Vector[Any, Scalar], b: Vector[Any, Scalar]) → Scalar

Modulo operation using truncated division.

warp.div(a: Scalar, b: Scalar) → Scalar

warp.div(a: Vector[Any, Scalar], b: Scalar) → Vector[Any, Scalar]

warp.div(a: Scalar, b: Vector[Any, Scalar]) → Vector[Any, Scalar]

warp.div(a: Matrix[Any, Any, Scalar], b: Scalar) → Matrix[Any, Any, Scalar]

warp.div(a: Scalar, b: Matrix[Any, Any, Scalar]) → Matrix[Any, Any, Scalar]

warp.div(a: Quaternion[Scalar], b: Scalar) → Quaternion[Scalar]

warp.div(a: Scalar, b: Quaternion[Scalar]) → Quaternion[Scalar]

warp.floordiv(a: Scalar, b: Scalar) → Scalar

warp.pos(x: Scalar) → Scalar

warp.pos(x: Vector[Any, Scalar]) → Vector[Any, Scalar]

warp.pos(x: Quaternion[Scalar]) → Quaternion[Scalar]

warp.pos(x: Matrix[Any, Any, Scalar]) → Matrix[Any, Any, Scalar]

warp.neg(x: Scalar) → Scalar

warp.neg(x: Vector[Any, Scalar]) → Vector[Any, Scalar]

warp.neg(x: Quaternion[Scalar]) → Quaternion[Scalar]

warp.neg(x: Matrix[Any, Any, Scalar]) → Matrix[Any, Any, Scalar]

warp.unot(a: bool) → bool

warp.unot(a: int8) → bool

warp.unot(a: uint8) → bool

warp.unot(a: int16) → bool

warp.unot(a: uint16) → bool

warp.unot(a: int32) → bool

warp.unot(a: uint32) → bool

warp.unot(a: int64) → bool

warp.unot(a: uint64) → bool

warp.unot(a: Array[Any]) → bool

Code Generation

warp.static(expr: Any) → Any

Evaluates a static Python expression and replaces it with its result.

See the code generation guide for more details.

The inner expression must only reference variables that are available from the current scope where the Warp kernel or function containing the expression is defined, which includes constant variables and variables captured in the current closure in which the function or kernel is implemented. The return type of the expression must be either a Warp function, a string, or a type that is supported inside Warp kernels and functions (excluding Warp arrays since they cannot be created in a Warp kernel at the moment).

Footnotes

[1] (1,2,3,4,5,6)

Function gradients have not been implemented for backpropagation.