Built-Ins Reference#

This section lists the Warp types and functions available to use from Warp kernels and optionally also from the Warp Python runtime API. For a listing of the API that is exclusively intended to be used at the Python Scope and run inside the CPython interpreter, see the Python Reference section.

Scalar Types#

class warp.int8[source]#
class warp.uint8[source]#
class warp.int16[source]#
class warp.uint16[source]#
class warp.int32[source]#
class warp.uint32[source]#
class warp.int64[source]#
class warp.uint64[source]#
class warp.float16[source]#
class warp.float32[source]#
class warp.float64[source]#
class warp.bool[source]#

Vector Types#

class warp.vec2b[source]#
class warp.vec2ub[source]#
class warp.vec2s[source]#
class warp.vec2us[source]#
class warp.vec2i[source]#
class warp.vec2ui[source]#
class warp.vec2l[source]#
class warp.vec2ul[source]#
class warp.vec2h[source]#
class warp.vec2f[source]#
class warp.vec2d[source]#
class warp.vec3b[source]#
class warp.vec3ub[source]#
class warp.vec3s[source]#
class warp.vec3us[source]#
class warp.vec3i[source]#
class warp.vec3ui[source]#
class warp.vec3l[source]#
class warp.vec3ul[source]#
class warp.vec3h[source]#
class warp.vec3f[source]#
class warp.vec3d[source]#
class warp.vec4b[source]#
class warp.vec4ub[source]#
class warp.vec4s[source]#
class warp.vec4us[source]#
class warp.vec4i[source]#
class warp.vec4ui[source]#
class warp.vec4l[source]#
class warp.vec4ul[source]#
class warp.vec4h[source]#
class warp.vec4f[source]#
class warp.vec4d[source]#
class warp.mat22h[source]#
class warp.mat22f[source]#
class warp.mat22d[source]#
class warp.mat33h[source]#
class warp.mat33f[source]#
class warp.mat33d[source]#
class warp.mat44h[source]#
class warp.mat44f[source]#
class warp.mat44d[source]#
class warp.quath[source]#
class warp.quatf[source]#
class warp.quatd[source]#
class warp.transformh[source]#
class warp.transformf[source]#
class warp.transformd[source]#
class warp.spatial_vectorh[source]#
class warp.spatial_vectorf[source]#
class warp.spatial_vectord[source]#
class warp.spatial_matrixh[source]#
class warp.spatial_matrixf[source]#
class warp.spatial_matrixd[source]#

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#
  • Kernel

  • Python

  • Differentiable

Return the minimum of two scalars.

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

  • Python

  • Differentiable

Return the element-wise minimum of two vectors.

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

  • Python

  • Differentiable

Return the minimum element of a vector a.

warp.max(a: Scalar, b: Scalar) Scalar#
  • Kernel

  • Python

  • Differentiable

Return the maximum of two scalars.

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

  • Python

  • Differentiable

Return the element-wise maximum of two vectors.

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

  • Python

  • Differentiable

Return the maximum element of a vector a.

warp.clamp(x: Scalar, low: Scalar, high: Scalar) Scalar#
  • Kernel

  • Python

  • Differentiable

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

warp.abs(x: Scalar) Scalar#
  • Kernel

  • Python

  • Differentiable

Return the absolute value of x.

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

  • Python

  • Differentiable

Return the absolute values of the elements of x.

warp.sign(x: Scalar) Scalar#
  • Kernel

  • Python

  • Differentiable

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

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

  • Python

  • Differentiable

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

warp.step(x: Scalar) Scalar#
  • Kernel

  • Python

  • Differentiable

Return 1.0 if x < 0.0, return 0.0 otherwise.

warp.nonzero(x: Scalar) Scalar#
  • Kernel

  • Python

  • Differentiable

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

warp.sin(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

Return the sine of x in radians.

warp.cos(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

Return the cosine of x in radians.

warp.acos(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

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

warp.asin(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

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

warp.sqrt(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

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

warp.cbrt(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

Return the cube root of x.

warp.tan(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

Return the tangent of x in radians.

warp.atan(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

Return the arctangent of x in radians.

warp.atan2(y: Float, x: Float) Float#
  • Kernel

  • Python

  • Differentiable

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

warp.sinh(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

Return the sinh of x.

warp.cosh(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

Return the cosh of x.

warp.tanh(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

Return the tanh of x.

warp.degrees(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

Convert x from radians into degrees.

warp.radians(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

Convert x from degrees into radians.

warp.log(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

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

warp.log2(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

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

warp.log10(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

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

warp.exp(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

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

warp.pow(x: Float, y: Float) Float#
  • Kernel

  • Python

  • Differentiable

Return the result of x raised to power of y.

warp.round(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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

warp.ceil(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

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

warp.frac(x: Float) Float#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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

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

  • Python

  • Differentiable

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

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

  • Python

  • Differentiable

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

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

  • Python

  • Differentiable

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

warp.isnan(a: Scalar) bool#
  • Kernel

  • Python

  • Differentiable

Return True if a is NaN, otherwise return False.

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

  • Python

  • Differentiable

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

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

  • Python

  • Differentiable

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

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

  • Python

  • Differentiable

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

warp.isinf(a: Scalar) bool#
  • Kernel

  • Python

  • Differentiable

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

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

  • Python

  • Differentiable

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

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

Compute the dot product between two vectors.

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

  • Python

  • Differentiable

Compute the dot product between two quaternions.

warp.ddot(a: Matrix[Any, Any, Scalar], b: Matrix[Any, Any, Scalar]) Scalar#
  • Kernel

  • Python

  • Differentiable

Compute the double dot product between two matrices.

warp.argmin(a: Vector[Any, Scalar]) uint32#
  • Kernel

  • Python

Return the index of the minimum element of a vector a.

warp.argmax(a: Vector[Any, Scalar]) uint32#
  • Kernel

  • Python

Return the index of the maximum element of a vector a.

warp.outer(
a: Vector[Any, Scalar],
b: Vector[Any, Scalar],
) Matrix[Any, Any, Scalar]#
  • Kernel

  • Python

  • Differentiable

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

warp.cross(a: Vector[3, Scalar], b: Vector[3, Scalar]) Vector[3, Scalar]#
  • Kernel

  • Python

  • Differentiable

Compute the cross product of two 3D vectors.

warp.skew(vec: Vector[3, Scalar]) Matrix[3, 3, Scalar]#
  • Kernel

  • Python

  • Differentiable

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

warp.length(a: Vector[Any, Float]) Float#
  • Kernel

  • Python

  • Differentiable

Compute the length of a floating-point vector a.

warp.length(a: Quaternion[Float]) Float
  • Kernel

  • Python

  • Differentiable

Compute the length of a quaternion a.

warp.length_sq(a: Vector[Any, Scalar]) Scalar#
  • Kernel

  • Python

  • Differentiable

Compute the squared length of a vector a.

warp.length_sq(a: Quaternion[Scalar]) Scalar
  • Kernel

  • Python

  • Differentiable

Compute the squared length of a quaternion a.

warp.normalize(a: Vector[Any, Float]) Vector[Any, Float]#
  • Kernel

  • Python

  • Differentiable

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

warp.normalize(a: Quaternion[Float]) Quaternion[Float]
  • Kernel

  • Python

  • Differentiable

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]#
  • Kernel

  • Python

  • Differentiable

Return the transpose of the matrix a.

warp.inverse(a: Matrix[2, 2, Float]) Matrix[Any, Any, Float]#
  • Kernel

  • Python

  • Differentiable

Return the inverse of a 2x2 matrix a.

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

  • Python

  • Differentiable

Return the inverse of a 3x3 matrix a.

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

  • Python

  • Differentiable

Return the inverse of a 4x4 matrix a.

warp.determinant(a: Matrix[2, 2, Float]) Float#
  • Kernel

  • Python

  • Differentiable

Return the determinant of a 2x2 matrix a.

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

  • Python

  • Differentiable

Return the determinant of a 3x3 matrix a.

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

  • Python

  • Differentiable

Return the determinant of a 4x4 matrix a.

warp.trace(a: Matrix[Any, Any, Scalar]) Scalar#
  • Kernel

  • Python

  • Differentiable

Return the trace of the matrix a.

warp.diag(vec: Vector[Any, Scalar]) Matrix[Any, Any, Scalar]#
  • Kernel

  • Python

  • Differentiable

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

warp.get_diag(mat: Matrix[Any, Any, Scalar]) Vector[Any, Scalar]#
  • Kernel

  • Python

  • Differentiable

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]#
  • Kernel

  • Python

  • Differentiable

Component-wise multiplication of two vectors.

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

  • Python

  • Differentiable

Component-wise multiplication of two matrices.

warp.cw_div(
a: Vector[Any, Scalar],
b: Vector[Any, Scalar],
) Vector[Any, Scalar]#
  • Kernel

  • Python

  • Differentiable

Component-wise division of two vectors.

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

  • Python

  • Differentiable

Component-wise division of two matrices.

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

  • Differentiable

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]#
  • Kernel

  • Differentiable

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]
  • Kernel

  • Differentiable

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

warp.matrix_from_cols(*args: Vector[Any, Scalar]) Matrix[Any, Any, Scalar]#
  • Kernel

  • Differentiable

Construct a matrix from column vectors.

warp.matrix_from_rows(*args: Vector[Any, Scalar]) Matrix[Any, Any, Scalar]#
  • Kernel

  • Differentiable

Construct a matrix from row vectors.

warp.identity(n: int32, dtype: Scalar) Matrix[Any, Any, Scalar]#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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.svd2(
A: Matrix[2, 2, Float],
U: Matrix[2, 2, Float],
sigma: Vector[2, Float],
V: Matrix[2, 2, Scalar],
) None#
  • Kernel

  • Differentiable

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

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

  • Differentiable

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#
  • Kernel

  • Differentiable

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.

warp.math.norm_l1(v)#
  • Kernel

  • Python

  • Differentiable

Computes the L1 norm of a vector v.

\[\|v\|_1 = \sum_i |v_i|\]
Parameters:

v (Vector[Any,Float]) – The vector to compute the L1 norm of.

Returns:

The L1 norm of the vector.

Return type:

float

warp.math.norm_l2(v)#
  • Kernel

  • Python

  • Differentiable

Computes the L2 norm of a vector v.

\[\|v\|_2 = \sqrt{\sum_i v_i^2}\]
Parameters:

v (Vector[Any,Float]) – The vector to compute the L2 norm of.

Returns:

The L2 norm of the vector.

Return type:

float

warp.math.norm_huber(v, delta=1.0)#
  • Kernel

  • Python

  • Differentiable

Computes the Huber norm of a vector v with a given delta.

\[\begin{split}H(v) = \begin{cases} \frac{1}{2} \|v\|^2 & \text{if } \|v\| \leq \delta \\ \delta(\|v\| - \frac{1}{2}\delta) & \text{otherwise} \end{cases}\end{split}\]
../_images/norm_huber.svg
Parameters:
  • v (Vector[Any,Float]) – The vector to compute the Huber norm of.

  • delta (float) – The threshold value, defaults to 1.0.

Returns:

The Huber norm of the vector.

Return type:

float

warp.math.norm_pseudo_huber(v, delta=1.0)#
  • Kernel

  • Python

  • Differentiable

Computes the “pseudo” Huber norm of a vector v with a given delta.

\[H^\prime(v) = \delta \sqrt{1 + \frac{\|v\|^2}{\delta^2}}\]
../_images/norm_pseudo_huber.svg
Parameters:
  • v (Vector[Any,Float]) – The vector to compute the Huber norm of.

  • delta (float) – The threshold value, defaults to 1.0.

Returns:

The Huber norm of the vector.

Return type:

float

warp.math.smooth_normalize(v, delta=1.0)#
  • Kernel

  • Python

  • Differentiable

Normalizes a vector using the pseudo-Huber norm.

See norm_pseudo_huber().

\[\frac{v}{H^\prime(v)}\]
Parameters:
  • v (Vector[Any,Float]) – The vector to normalize.

  • delta (float) – The threshold value, defaults to 1.0.

Returns:

The normalized vector.

Return type:

Vector[Any,Float]

Quaternion Math#

warp.quaternion(dtype: Float) Quaternion[Float]#
  • Kernel

  • Differentiable

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,
dtype: Scalar,
) Quaternion[Float]
  • Kernel

  • Differentiable

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

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

  • Differentiable

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

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

  • Differentiable

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

warp.quat_identity(dtype: Float) quatf#
  • Kernel

  • Python

  • Differentiable

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]#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Differentiable

Extract the rotation axis and angle radians a quaternion represents.

warp.quat_from_matrix(mat: Matrix[3, 3, Float]) Quaternion[Float]#
  • Kernel

  • Python

  • Differentiable

Construct a quaternion from a 3x3 matrix.

If the matrix is not a pure rotation, but for example includes scaling or skewing, the result is undefined.

warp.quat_from_matrix(mat: Matrix[4, 4, Float]) Quaternion[Float]
  • Kernel

  • Python

  • Differentiable

Construct a quaternion from a 4x4 matrix.

If the top-left 3x3 block of the matrix is not a pure rotation, but for example includes scaling or skewing, the result is undefined.

warp.quat_rpy(roll: Float, pitch: Float, yaw: Float) Quaternion[Float]#
  • Kernel

  • Python

  • Differentiable

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

warp.quat_inverse(quat: Quaternion[Float]) Quaternion[Float]#
  • Kernel

  • Python

  • Differentiable

Compute quaternion conjugate.

warp.quat_rotate(
quat: Quaternion[Float],
vec: Vector[3, Float],
) Vector[3, Float]#
  • Kernel

  • Python

  • Differentiable

Rotate a vector by a quaternion.

warp.quat_rotate_inv(
quat: Quaternion[Float],
vec: Vector[3, Float],
) Vector[3, Float]#
  • Kernel

  • Python

  • Differentiable

Rotate a vector by the inverse of a quaternion.

warp.quat_slerp(
a: Quaternion[Float],
b: Quaternion[Float],
t: Float,
) Quaternion[Float]#
  • Kernel

  • Python

  • Differentiable

Linearly interpolate between two quaternions.

warp.quat_to_matrix(quat: Quaternion[Float]) Matrix[3, 3, Float]#
  • Kernel

  • Python

  • Differentiable

Convert a quaternion to a 3x3 rotation matrix.

Transformations#

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

  • Differentiable

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

warp.transform_identity(dtype: Float) transformf#
  • Kernel

  • Python

  • Differentiable

Construct an identity transform with zero translation and identity rotation.

warp.transform_get_translation(
xform: Transformation[Float],
) Vector[3, Float]#
  • Kernel

  • Python

  • Differentiable

Return the translational part of a transform xform.

warp.transform_get_rotation(
xform: Transformation[Float],
) Quaternion[Float]#
  • Kernel

  • Python

  • Differentiable

Return the rotational part of a transform xform.

warp.transform_multiply(
a: Transformation[Float],
b: Transformation[Float],
) Transformation[Float]#
  • Kernel

  • Python

  • Differentiable

Multiply two rigid body transformations together.

warp.transform_point(
xform: Transformation[Float],
point: Vector[3, Float],
) Vector[3, Float]#
  • Kernel

  • Python

  • Differentiable

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]
  • Kernel

  • Python

  • Differentiable

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]#
  • Kernel

  • Python

  • Differentiable

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]
  • Kernel

  • Python

  • Differentiable

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]#
  • Kernel

  • Python

  • Differentiable

Compute the inverse of the transformation xform.

warp.math.transform_from_matrix(mat)#
  • Kernel

  • Python

  • Differentiable

Construct a transformation from a 4x4 matrix.

Parameters:

mat (Matrix[4, 4, Float]) – Matrix to convert.

Returns:

The transformation.

Return type:

Transformation[Float]

warp.math.transform_to_matrix(xform)#
  • Kernel

  • Python

  • Differentiable

Convert a transformation to a 4x4 matrix.

Parameters:

xform (Transformation[Float]) – Transformation to convert.

Returns:

The matrix.

Return type:

Matrix[4, 4, Float]

Spatial Math#

warp.spatial_vector(dtype: Float) Vector[6, Float][source]#
  • Kernel

  • Differentiable

Zero-initialize a 6D screw vector.

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

  • Differentiable

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][source]
  • Kernel

  • Differentiable

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]#
  • Kernel

  • Differentiable

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

warp.spatial_dot(a: Vector[6, Float], b: Vector[6, Float]) Float#
  • Kernel

  • Python

  • Differentiable

Compute the dot product of two 6D screw vectors.

warp.spatial_cross(
a: Vector[6, Float],
b: Vector[6, Float],
) Vector[6, Float]#
  • Kernel

  • Python

  • Differentiable

Compute the cross product of two 6D screw vectors.

warp.spatial_cross_dual(
a: Vector[6, Float],
b: Vector[6, Float],
) Vector[6, Float]#
  • Kernel

  • Python

  • Differentiable

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

warp.spatial_top(svec: Vector[6, Float]) Vector[3, Float]#
  • Kernel

  • Python

  • Differentiable

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

warp.spatial_bottom(svec: Vector[6, Float]) Vector[3, Float]#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Differentiable

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

  • Differentiable

Tile Primitives#

warp.tile_zeros(shape: Tuple[int, ...], dtype: Any, storage: str) Tile#
  • Kernel

Allocate a tile of zero-initialized items.

Parameters:
  • shape – Shape of the output tile

  • dtype – Data type of output tile’s elements (default float)

  • storage – The storage location for the tile: "register" for registers (default) or "shared" for shared memory.

Returns:

A zero-initialized tile with shape and data type as specified

warp.tile_ones(shape: Tuple[int, ...], dtype: Any, storage: str) Tile#
  • Kernel

Allocate a tile of one-initialized items.

Parameters:
  • shape – Shape of the output tile

  • dtype – Data type of output tile’s elements

  • storage – The storage location for the tile: "register" for registers (default) or "shared" for shared memory.

Returns:

A one-initialized tile with shape and data type as specified

warp.tile_arange(*args: Scalar, dtype: Any, storage: str) Tile#
  • Kernel

Generate a tile of linearly spaced elements.

Parameters:
  • args

    Variable-length positional arguments, interpreted as:

    • (stop,): Generates values from 0 to stop - 1

    • (start, stop): Generates values from start to stop - 1

    • (start, stop, step): Generates values from start to stop - 1 with a step size

  • dtype – Data type of output tile’s elements (optional, default: float)

  • storage – The storage location for the tile: "register" for registers (default) or "shared" for shared memory.

Returns:

A tile with shape=(n) with linearly spaced elements of specified data type

warp.tile_load(
a: Array[Any],
shape: Tuple[int, ...],
offset: Tuple[int, ...],
storage: str,
) Array[Scalar]#
  • Kernel

  • Differentiable

Loads a tile from a global memory array.

This method will cooperatively load a tile from global memory using all threads in the block.

Parameters:
  • a – The source array in global memory

  • shape – Shape of the tile to load, must have the same number of dimensions as a

  • offset – Offset in the source array to begin reading from (optional)

  • storage – The storage location for the tile: "register" for registers (default) or "shared" for shared memory.

Returns:

A tile with shape as specified and data type the same as the source array

warp.tile_store(a: Array[Any], t: Tile, offset: Tuple[int, ...]) None#
  • Kernel

  • Differentiable

Store a tile to a global memory array.

This method will cooperatively store a tile to global memory using all threads in the block.

Parameters:
  • a – The destination array in global memory

  • t – The source tile to store data from, must have the same data type and number of dimensions as the destination array

  • offset – Offset in the destination array (optional)

warp.tile_atomic_add(
a: Array[Any],
t: Tile,
offset: Tuple[int, ...],
) Tile#
  • Kernel

  • Differentiable

Atomically add a 1D tile to the array a, each element will be updated atomically.

Parameters:
  • a – Array in global memory, should have the same dtype as the input tile

  • t – Source tile to add to the destination array

  • offset – Offset in the destination array (optional)

Returns:

A tile with the same dimensions and data type as the source tile, holding the original value of the destination elements

warp.tile_view(
t: Tile,
offset: Tuple[int, ...],
shape: Tuple[int, ...],
) Tile#
  • Kernel

Return a slice of a given tile [offset, offset+shape], if shape is not specified it will be inferred from the unspecified offset dimensions.

Parameters:
  • t – Input tile to extract a subrange from

  • offset – Offset in the source tile

  • shape – Shape of the returned slice

Returns:

A tile with dimensions given by the specified shape or the remaining source tile dimensions

warp.tile_assign(dst: Tile, src: Tile, offset: Tuple[int, ...]) None#
  • Kernel

  • Differentiable

Assign a tile to a subrange of a destination tile.

Parameters:
  • dst – The destination tile to assign to

  • src – The source tile to read values from

  • offset – Offset in the destination tile to write to

warp.tile(x: Any) Tile#
  • Kernel

  • Differentiable

Construct a new tile from per-thread kernel values.

This function converts values computed using scalar kernel code to a tile representation for input into collective operations.

  • If the input value is a scalar, then the resulting tile has shape=(block_dim,)

  • If the input value is a vector, then the resulting tile has shape=(length(vector), block_dim)

Parameters:

x – A per-thread local value, e.g. scalar, vector, or matrix.

Returns:

A tile with first dimension according to the value type length and a second dimension equal to block_dim

This example shows how to create a linear sequence from thread variables:

@wp.kernel
def compute():
    i = wp.tid()
    t = wp.tile(i*2)
    print(t)

wp.launch(compute, dim=16, inputs=[], block_dim=16)

Prints:

[0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30] = tile(shape=(16), storage=register)
warp.untile(a: Tile) Scalar#
  • Kernel

  • Differentiable

Convert a tile back to per-thread values.

This function converts a block-wide tile back to per-thread values.

  • If the input tile is 1D, then the resulting value will be a per-thread scalar

  • If the input tile is 2D, then the resulting value will be a per-thread vector of length M

Parameters:

a – A tile with dimensions shape=(M, block_dim)

Returns:

A single value per-thread with the same data type as the tile

This example shows how to create a linear sequence from thread variables:

@wp.kernel
def compute():
    i = wp.tid()

    # create block-wide tile
    t = wp.tile(i)*2

    # convert back to per-thread values
    s = wp.untile(t)

    print(s)

wp.launch(compute, dim=16, inputs=[], block_dim=16)

Prints:

0
2
4
6
8
...
warp.tile_transpose(a: Tile) Tile#
  • Kernel

  • Differentiable

Transpose a tile.

For shared memory tiles, this operation will alias the input tile. Register tiles will first be transferred to shared memory before transposition.

Parameters:

a – Tile to transpose with shape=(M,N)

Returns:

Tile with shape=(N,M)

warp.tile_broadcast(a: Tile, shape: Tuple[int, ...]) Tile#
  • Kernel

  • Differentiable

Broadcast a tile.

Broadcasts the input tile a to the destination shape. Broadcasting follows NumPy broadcast rules.

Parameters:
  • a – Tile to broadcast

  • shape – The shape to broadcast to

Returns:

Tile with broadcast shape

warp.tile_sum(a: Tile) Tile#
  • Kernel

  • Differentiable

Cooperatively compute the sum of the tile elements using all threads in the block.

Parameters:

a – The tile to compute the sum of

Returns:

A single-element tile holding the sum

Example:

@wp.kernel
def compute():

    t = wp.tile_ones(dtype=float, shape=(16, 16))
    s = wp.tile_sum(t)

    print(s)

wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=64)

Prints:

[256] = tile(shape=(1), storage=register)
warp.tile_min(a: Tile) Tile#
  • Kernel

  • Differentiable

Cooperatively compute the minimum of the tile elements using all threads in the block.

Parameters:

a – The tile to compute the minimum of

Returns:

A single-element tile holding the minimum value

Example:

@wp.kernel
def compute():

    t = wp.tile_arange(64, 128)
    s = wp.tile_min(t)

    print(s)


wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=64)

Prints:

[64] = tile(shape=(1), storage=register)
warp.tile_max(a: Tile) Tile#
  • Kernel

  • Differentiable

Cooperatively compute the maximum of the tile elements using all threads in the block.

Parameters:

a – The tile to compute the maximum from

Returns:

A single-element tile holding the maximum value

Example:

@wp.kernel
def compute():

    t = wp.tile_arange(64, 128)
    s = wp.tile_max(t)

    print(s)

wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=64)

Prints:

[127] = tile(shape=(1), storage=register)
warp.tile_reduce(op: Callable, a: Tile) Tile#
  • Kernel

  • Differentiable

Apply a custom reduction operator across the tile.

This function cooperatively performs a reduction using the provided operator across the tile.

Parameters:
  • op – A callable function that accepts two arguments and returns one argument, may be a user function or builtin

  • a – The input tile, the operator (or one of its overloads) must be able to accept the tile’s data type

Returns:

A single-element tile with the same data type as the input tile.

Example:

@wp.kernel
def factorial():

    t = wp.tile_arange(1, 10, dtype=int)
    s = wp.tile_reduce(wp.mul, t)

    print(s)

wp.launch_tiled(factorial, dim=[1], inputs=[], block_dim=16)

Prints:

[362880] = tile(shape=(1), storage=register)
warp.tile_map(op: Callable, a: Tile) Tile#
  • Kernel

  • Differentiable

Apply a unary function onto the tile.

This function cooperatively applies a unary function to each element of the tile using all threads in the block.

Parameters:
  • op – A callable function that accepts one argument and returns one argument, may be a user function or builtin

  • a – The input tile, the operator (or one of its overloads) must be able to accept the tile’s data type

Returns:

A tile with the same dimensions and data type as the input tile.

Example:

@wp.kernel
def compute():

    t = wp.tile_arange(0.0, 1.0, 0.1, dtype=float)
    s = wp.tile_map(wp.sin, t)

    print(s)

wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=16)

Prints:

[0 0.0998334 0.198669 0.29552 0.389418 0.479426 0.564642 0.644218 0.717356 0.783327] = tile(shape=(10), storage=register)
warp.tile_map(op: Callable, a: Tile, b: Tile) Tile
  • Kernel

  • Differentiable

Apply a binary function onto the tile.

This function cooperatively applies a binary function to each element of the tiles using all threads in the block. Both input tiles must have the same dimensions and datatype.

Parameters:
  • op – A callable function that accepts two arguments and returns one argument, all of the same type, may be a user function or builtin

  • a – The first input tile, the operator (or one of its overloads) must be able to accept the tile’s dtype

  • b – The second input tile, the operator (or one of its overloads) must be able to accept the tile’s dtype

Returns:

A tile with the same dimensions and datatype as the input tiles.

Example:

@wp.kernel
def compute():

    a = wp.tile_arange(0.0, 1.0, 0.1, dtype=float)
    b = wp.tile_ones(shape=10, dtype=float)

    s = wp.tile_map(wp.add, a, b)

    print(s)

wp.launch_tiled(compute, dim=[1], inputs=[], block_dim=16)

Prints:

[1 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9] = tile(shape=(10), storage=register)
warp.tile_diag_add(a: Tile, d: Tile) Tile#
  • Kernel

  • Differentiable

Add a square matrix and a diagonal matrix ‘d’ represented as a 1D tile

warp.tile_matmul(a: Tile, b: Tile, out: Tile) Tile#
  • Kernel

  • Differentiable

Computes the matrix product and accumulates out += a*b.

Supported datatypes are:
  • fp16, fp32, fp64 (real)

  • vec2h, vec2f, vec2d (complex)

All input and output tiles must have the same datatype. Tile data will automatically be migrated to shared memory if necessary and will use TensorCore operations when available.

Parameters:
  • a – A tile with shape=(M, K)

  • b – A tile with shape=(K, N)

  • out – A tile with shape=(M, N)

warp.tile_matmul(a: Tile, b: Tile) Tile
  • Kernel

  • Differentiable

Computes the matrix product out = a*b.

Supported datatypes are:
  • fp16, fp32, fp64 (real)

  • vec2h, vec2f, vec2d (complex)

Both input tiles must have the same datatype. Tile data will automatically be migrated to shared memory if necessary and will use TensorCore operations when available.

Parameters:
  • a – A tile with shape=(M, K)

  • b – A tile with shape=(K, N)

Returns:

A tile with shape=(M, N)

warp.tile_fft(inout: Tile) Tile#
  • Kernel

  • Differentiable

Compute the forward FFT along the second dimension of a 2D tile of data.

This function cooperatively computes the forward FFT on a tile of data inplace, treating each row individually.

Note that computing the adjoint is not yet supported.

Supported datatypes are:
  • vec2f, vec2d

Parameters:

inout – The input/output tile

warp.tile_ifft(inout: Tile) Tile#
  • Kernel

  • Differentiable

Compute the inverse FFT along the second dimension of a 2D tile of data.

This function cooperatively computes the inverse FFT on a tile of data inplace, treating each row individually.

Note that computing the adjoint is not yet supported.

Supported datatypes are:
  • vec2f, vec2d

Parameters:

inout – The input/output tile

warp.tile_cholesky(A: Tile) Tile#
  • Kernel

  • Differentiable

Compute the Cholesky factorization L of a matrix A. L is lower triangular and satisfies LL^T = A.

Note that computing the adjoint is not yet supported.

Supported datatypes are:
  • float32

  • float64

Parameters:

A – A square, symmetric positive-definite, matrix.

Returns L:

A square, lower triangular, matrix, such that LL^T = A

warp.tile_cholesky_solve(L: Tile, x: Tile) None#
  • Kernel

  • Differentiable

With L such that LL^T = A, solve for x in Ax = y

Note that computing the adjoint is not yet supported.

Supported datatypes are:
  • float32

  • float64

Parameters:
  • L – A square, lower triangular, matrix, such that LL^T = A

  • x – An 1D tile of length M

Returns y:

An 1D tile of length M such that LL^T y = x

Utility#

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

  • Differentiable

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

Deprecated since version 1.6: Use tile primitives instead.

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.reversed(range: range_t) range_t#
  • Kernel

  • Differentiable

Returns the range in reversed order.

warp.printf(fmt: str, *args: Any) None#
  • Kernel

  • Differentiable

Allows printing formatted strings using C-style format specifiers.

warp.print(value: Any) None#
  • Kernel

  • Differentiable

Print variable to stdout

warp.breakpoint() None#
  • Kernel

  • Differentiable

Debugger breakpoint

warp.tid() int#
  • Kernel

  • Differentiable

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]
  • Kernel

  • Differentiable

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]
  • Kernel

  • Differentiable

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]
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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

Deprecated since version 1.7: Use where() instead, which has the more intuitive argument order: where(cond, value_if_true, value_if_false).

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

  • Differentiable

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

Deprecated since version 1.7: Use where() instead, which has the more intuitive argument order: where(cond, value_if_true, value_if_false).

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

  • Differentiable

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

Deprecated since version 1.7: Use where() instead, which has the more intuitive argument order: where(cond, value_if_true, value_if_false).

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

  • Differentiable

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

Deprecated since version 1.7: Use where() instead, which has the more intuitive argument order: where(cond, value_if_true, value_if_false).

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

  • Differentiable

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

Deprecated since version 1.7: Use where() instead, which has the more intuitive argument order: where(cond, value_if_true, value_if_false).

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

  • Differentiable

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

Deprecated since version 1.7: Use where() instead, which has the more intuitive argument order: where(cond, value_if_true, value_if_false).

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

  • Differentiable

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

Deprecated since version 1.7: Use where() instead, which has the more intuitive argument order: where(cond, value_if_true, value_if_false).

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

  • Differentiable

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

Deprecated since version 1.7: Use where() instead, which has the more intuitive argument order: where(cond, value_if_true, value_if_false).

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

  • Differentiable

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

Deprecated since version 1.7: Use where() instead, which has the more intuitive argument order: where(cond, value_if_true, value_if_false).

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

  • Differentiable

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

Deprecated since version 1.7: Use where() instead, which has the more intuitive argument order: where(arr, value_if_true, value_if_false).

warp.where(cond: bool, value_if_true: Any, value_if_false: Any) Any#
  • Kernel

  • Differentiable

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

warp.where(cond: int8, value_if_true: Any, value_if_false: Any) Any
  • Kernel

  • Differentiable

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

warp.where(cond: uint8, value_if_true: Any, value_if_false: Any) Any
  • Kernel

  • Differentiable

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

warp.where(cond: int16, value_if_true: Any, value_if_false: Any) Any
  • Kernel

  • Differentiable

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

warp.where(cond: uint16, value_if_true: Any, value_if_false: Any) Any
  • Kernel

  • Differentiable

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

warp.where(cond: int32, value_if_true: Any, value_if_false: Any) Any
  • Kernel

  • Differentiable

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

warp.where(cond: uint32, value_if_true: Any, value_if_false: Any) Any
  • Kernel

  • Differentiable

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

warp.where(cond: int64, value_if_true: Any, value_if_false: Any) Any
  • Kernel

  • Differentiable

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

warp.where(cond: uint64, value_if_true: Any, value_if_false: Any) Any
  • Kernel

  • Differentiable

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

warp.where(arr: Array[Any], value_if_true: Any, value_if_false: Any) Any
  • Kernel

  • Differentiable

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

warp.atomic_add(arr: Array[Any], i: Int, value: Any) Any#
  • Kernel

  • Differentiable

Atomically adds value onto arr[i] and returns the original value of arr[i].

This function is automatically invoked when using the syntax arr[i] += value.

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

  • Differentiable

Atomically adds value onto arr[i,j] and returns the original value of arr[i,j].

This function is automatically invoked when using the syntax arr[i,j] += value.

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

  • Differentiable

Atomically adds value onto arr[i,j,k] and returns the original value of arr[i,j,k].

This function is automatically invoked when using the syntax arr[i,j,k] += value.

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

  • Differentiable

Atomically adds value onto arr[i,j,k,l] and returns the original value of arr[i,j,k,l].

This function is automatically invoked when using the syntax arr[i,j,k,l] += value.

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

  • Differentiable

Atomically adds value onto arr[i] and returns the original value of arr[i].

This function is automatically invoked when using the syntax arr[i] += value.

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

  • Differentiable

Atomically adds value onto arr[i,j] and returns the original value of arr[i,j].

This function is automatically invoked when using the syntax arr[i,j] += value.

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

  • Differentiable

Atomically adds value onto arr[i,j,k] and returns the original value of arr[i,j,k].

This function is automatically invoked when using the syntax arr[i,j,k] += value.

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

  • Differentiable

Atomically adds value onto arr[i,j,k,l] and returns the original value of arr[i,j,k,l].

This function is automatically invoked when using the syntax arr[i,j,k,l] += value.

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

  • Differentiable

Atomically adds value onto arr[i] and returns the original value of arr[i].

This function is automatically invoked when using the syntax arr[i] += value.

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

  • Differentiable

Atomically adds value onto arr[i,j] and returns the original value of arr[i,j].

This function is automatically invoked when using the syntax arr[i,j] += value.

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

  • Differentiable

Atomically adds value onto arr[i,j,k] and returns the original value of arr[i,j,k].

This function is automatically invoked when using the syntax arr[i,j,k] += value.

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

  • Differentiable

Atomically adds value onto arr[i,j,k,l] and returns the original value of arr[i,j,k,l].

This function is automatically invoked when using the syntax arr[i,j,k,l] += value.

warp.atomic_sub(arr: Array[Any], i: Int, value: Any) Any#
  • Kernel

  • Differentiable

Atomically subtracts value onto arr[i] and returns the original value of arr[i].

This function is automatically invoked when using the syntax arr[i] -= value.

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

  • Differentiable

Atomically subtracts value onto arr[i,j] and returns the original value of arr[i,j].

This function is automatically invoked when using the syntax arr[i,j] -= value.

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

  • Differentiable

Atomically subtracts value onto arr[i,j,k] and returns the original value of arr[i,j,k].

This function is automatically invoked when using the syntax arr[i,j,k] -= value.

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

  • Differentiable

Atomically subtracts value onto arr[i,j,k,l] and returns the original value of arr[i,j,k,l].

This function is automatically invoked when using the syntax arr[i,j,k,l] -= value.

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

  • Differentiable

Atomically subtracts value onto arr[i] and returns the original value of arr[i].

This function is automatically invoked when using the syntax arr[i] -= value.

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

  • Differentiable

Atomically subtracts value onto arr[i,j] and returns the original value of arr[i,j].

This function is automatically invoked when using the syntax arr[i,j] -= value.

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

  • Differentiable

Atomically subtracts value onto arr[i,j,k] and returns the original value of arr[i,j,k].

This function is automatically invoked when using the syntax arr[i,j,k] -= value.

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

  • Differentiable

Atomically subtracts value onto arr[i,j,k,l] and returns the original value of arr[i,j,k,l].

This function is automatically invoked when using the syntax arr[i,j,k,l] -= value.

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

  • Differentiable

Atomically subtracts value onto arr[i] and returns the original value of arr[i].

This function is automatically invoked when using the syntax arr[i] -= value.

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

  • Differentiable

Atomically subtracts value onto arr[i,j] and returns the original value of arr[i,j].

This function is automatically invoked when using the syntax arr[i,j] -= value.

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

  • Differentiable

Atomically subtracts value onto arr[i,j,k] and returns the original value of arr[i,j,k].

This function is automatically invoked when using the syntax arr[i,j,k] -= value.

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

  • Differentiable

Atomically subtracts value onto arr[i,j,k,l] and returns the original value of arr[i,j,k,l].

This function is automatically invoked when using the syntax arr[i,j,k,l] -= value.

warp.atomic_min(arr: Array[Any], i: Int, value: Any) Any#
  • Kernel

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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#
  • Kernel

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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]
  • Kernel

  • Python

  • Differentiable

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]
  • Kernel

  • Python

  • Differentiable

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]
  • Kernel

  • Python

  • Differentiable

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]
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Differentiable

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

warp.expect_near(
a: Vector[Any, Float],
b: Vector[Any, Float],
tolerance: Float,
) None
  • Kernel

  • Differentiable

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

warp.expect_near(
a: Quaternion[Float],
b: Quaternion[Float],
tolerance: Float,
) None
  • Kernel

  • Differentiable

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

warp.expect_near(
a: Matrix[Any, Any, Float],
b: Matrix[Any, Any, Float],
tolerance: Float,
) None
  • Kernel

  • Differentiable

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

warp.len(a: Vector[Any, Scalar]) int#
  • Kernel

  • Differentiable

Return the number of elements in a vector.

warp.len(a: Quaternion[Scalar]) int
  • Kernel

  • Differentiable

Return the number of elements in a quaternion.

warp.len(a: Matrix[Any, Any, Scalar]) int
  • Kernel

  • Differentiable

Return the number of rows in a matrix.

warp.len(a: Transformation[Float]) int
  • Kernel

  • Differentiable

Return the number of elements in a transformation.

warp.len(a: Array[Any]) int
  • Kernel

  • Differentiable

Return the size of the first dimension in an array.

warp.len(a: Tile) int
  • Kernel

  • Differentiable

Return the number of rows in a tile.

Geometry#

warp.BvhQuery[source]#

alias of bvh_query_t

warp.bvh_query_aabb(id: uint64, low: vec3f, high: vec3f) bvh_query_t#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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[source]#

alias of mesh_query_point_t

warp.mesh_query_point(
id: uint64,
point: vec3f,
max_dist: float32,
) mesh_query_point_t#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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[source]#

alias of mesh_query_ray_t

warp.mesh_query_ray(
id: uint64,
start: vec3f,
dir: vec3f,
max_t: float32,
) mesh_query_ray_t#
  • Kernel

  • Differentiable

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[source]#

alias of mesh_query_aabb_t

warp.mesh_query_aabb(
id: uint64,
low: vec3f,
high: vec3f,
) mesh_query_aabb_t#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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

warp.HashGridQuery[source]#

alias of hash_grid_query_t

warp.hash_grid_query(
id: uint64,
point: vec3f,
max_dist: float32,
) hash_grid_query_t#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

Retrieves the mesh given its index.

warp.mesh_eval_face_normal(id: uint64, face: int32) vec3f#
  • Kernel

  • Differentiable

Evaluates the face normal the mesh given a face index.

warp.mesh_get_point(id: uint64, index: int32) vec3f#
  • Kernel

  • Differentiable

Returns the point of the mesh given a index.

warp.mesh_get_velocity(id: uint64, index: int32) vec3f#
  • Kernel

  • Differentiable

Returns the velocity of the mesh given a index.

warp.mesh_get_index(id: uint64, index: int32) int#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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

warp.volume_sample_f(id: uint64, uvw: vec3f, sampling_mode: int32) float#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Differentiable

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

warp.volume_sample_v(id: uint64, uvw: vec3f, sampling_mode: int32) vec3f#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Differentiable

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

warp.volume_sample_i(id: uint64, uvw: vec3f) int#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

Return a random integer in the range [-2^31, 2^31).

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

  • Python

  • Differentiable

Return a random integer between [low, high).

warp.randu(state: uint32) uint32#
  • Kernel

  • Python

  • Differentiable

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

warp.randu(state: uint32, low: uint32, high: uint32) uint32
  • Kernel

  • Python

  • Differentiable

Return a random unsigned integer between [low, high).

warp.randf(state: uint32) float#
  • Kernel

  • Python

  • Differentiable

Return a random float between [0.0, 1.0).

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

  • Python

  • Differentiable

Return a random float between [low, high).

warp.randn(state: uint32) float#
  • Kernel

  • Python

  • Differentiable

Sample a normal (Gaussian) distribution of mean 0 and variance 1.

warp.sample_cdf(state: uint32, cdf: Array[float32]) int#
  • Kernel

  • Differentiable

Inverse-transform sample a cumulative distribution function.

warp.sample_triangle(state: uint32) vec2f#
  • Kernel

  • Python

  • Differentiable

Uniformly sample a triangle. Returns sample barycentric coordinates.

warp.sample_unit_ring(state: uint32) vec2f#
  • Kernel

  • Python

  • Differentiable

Uniformly sample a ring in the xy plane.

warp.sample_unit_disk(state: uint32) vec2f#
  • Kernel

  • Python

  • Differentiable

Uniformly sample a disk in the xy plane.

warp.sample_unit_sphere_surface(state: uint32) vec3f#
  • Kernel

  • Python

  • Differentiable

Uniformly sample a unit sphere surface.

warp.sample_unit_sphere(state: uint32) vec3f#
  • Kernel

  • Python

  • Differentiable

Uniformly sample a unit sphere.

warp.sample_unit_hemisphere_surface(state: uint32) vec3f#
  • Kernel

  • Python

  • Differentiable

Uniformly sample a unit hemisphere surface.

warp.sample_unit_hemisphere(state: uint32) vec3f#
  • Kernel

  • Python

  • Differentiable

Uniformly sample a unit hemisphere.

warp.sample_unit_square(state: uint32) vec2f#
  • Kernel

  • Python

  • Differentiable

Uniformly sample a unit square.

warp.sample_unit_cube(state: uint32) vec3f#
  • Kernel

  • Python

  • Differentiable

Uniformly sample a unit cube.

warp.poisson(state: uint32, lam: float32) uint32#
  • Kernel

  • Python

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

Non-periodic Perlin-style noise in 1D.

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

  • Python

  • Differentiable

Non-periodic Perlin-style noise in 2D.

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

  • Python

  • Differentiable

Non-periodic Perlin-style noise in 3D.

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

  • Python

  • Differentiable

Non-periodic Perlin-style noise in 4D.

warp.pnoise(state: uint32, x: float32, px: int32) float#
  • Kernel

  • Python

  • Differentiable

Periodic Perlin-style noise in 1D.

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

  • Python

  • Differentiable

Periodic Perlin-style noise in 2D.

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

  • Python

  • Differentiable

Periodic Perlin-style noise in 3D.

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

  • Python

  • Differentiable

Periodic Perlin-style noise in 4D.

warp.curlnoise(
state: uint32,
xy: vec2f,
octaves: uint32,
lacunarity: float32,
gain: float32,
) vec2f#
  • Kernel

  • Python

Divergence-free vector field based on the gradient of a Perlin noise function.

warp.curlnoise(
state: uint32,
xyz: vec3f,
octaves: uint32,
lacunarity: float32,
gain: float32,
) vec3f
  • Kernel

  • Python

Divergence-free vector field based on the curl of three Perlin noise functions.

warp.curlnoise(
state: uint32,
xyzt: vec4f,
octaves: uint32,
lacunarity: float32,
gain: float32,
) vec3f
  • Kernel

  • Python

Divergence-free vector field based on the curl of three Perlin noise functions.

Other#

warp.lower_bound(arr: Array[Scalar], value: Scalar) int#
  • Kernel

  • Differentiable

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

  • Differentiable

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#
  • Kernel

  • Python

  • Differentiable

warp.bit_or(a: Int, b: Int) Int#
  • Kernel

  • Python

  • Differentiable

warp.bit_xor(a: Int, b: Int) Int#
  • Kernel

  • Python

  • Differentiable

warp.lshift(a: Int, b: Int) Int#
  • Kernel

  • Python

  • Differentiable

warp.rshift(a: Int, b: Int) Int#
  • Kernel

  • Python

  • Differentiable

warp.invert(a: Int) Int#
  • Kernel

  • Python

  • Differentiable

Operators#

warp.add(a: Scalar, b: Scalar) Scalar#
  • Kernel

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

warp.add(a: Tile, b: Tile) Tile
  • Kernel

  • Python

  • Differentiable

Add each element of two tiles together

warp.sub(a: Scalar, b: Scalar) Scalar#
  • Kernel

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

warp.sub(a: Tile, b: Tile) Tile
  • Kernel

  • Python

  • Differentiable

Subtract each element b from a

warp.mul(a: Scalar, b: Scalar) Scalar#
  • Kernel

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

warp.mul(x: Tile, y: Scalar) Tile
  • Kernel

  • Python

  • Differentiable

Multiply each element of a tile by a scalar

warp.mul(x: Scalar, y: Tile) Tile
  • Kernel

  • Python

  • Differentiable

Multiply each element of a tile by a scalar

warp.mod(a: Scalar, b: Scalar) Scalar#
  • Kernel

  • Python

  • Differentiable

Modulo operation using truncated division.

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

  • Python

  • Differentiable

Modulo operation using truncated division.

warp.div(a: Scalar, b: Scalar) Scalar#
  • Kernel

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

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

  • Python

  • Differentiable

warp.floordiv(a: Scalar, b: Scalar) Scalar#
  • Kernel

  • Python

  • Differentiable

warp.pos(x: Scalar) Scalar#
  • Kernel

  • Python

  • Differentiable

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

  • Python

  • Differentiable

warp.pos(x: Quaternion[Scalar]) Quaternion[Scalar]
  • Kernel

  • Python

  • Differentiable

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

  • Python

  • Differentiable

warp.neg(x: Scalar) Scalar#
  • Kernel

  • Python

  • Differentiable

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

  • Python

  • Differentiable

warp.neg(x: Quaternion[Scalar]) Quaternion[Scalar]
  • Kernel

  • Python

  • Differentiable

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

  • Python

  • Differentiable

warp.neg(x: Tile) Tile
  • Kernel

  • Python

  • Differentiable

Negate each element of a tile

warp.unot(a: bool) bool#
  • Kernel

  • Python

  • Differentiable

warp.unot(a: int8) bool
  • Kernel

  • Python

  • Differentiable

warp.unot(a: uint8) bool
  • Kernel

  • Python

  • Differentiable

warp.unot(a: int16) bool
  • Kernel

  • Python

  • Differentiable

warp.unot(a: uint16) bool
  • Kernel

  • Python

  • Differentiable

warp.unot(a: int32) bool
  • Kernel

  • Python

  • Differentiable

warp.unot(a: uint32) bool
  • Kernel

  • Python

  • Differentiable

warp.unot(a: int64) bool
  • Kernel

  • Python

  • Differentiable

warp.unot(a: uint64) bool
  • Kernel

  • Python

  • Differentiable

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

  • Python

  • Differentiable

Code Generation#

warp.static(expr: Any) Any[source]#
  • Kernel

  • Differentiable

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