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#

Query Types#

class warp.bvh_query_t#: Object used to track state during BVH traversal.

class warp.hash_grid_query_t#: Object used to track state during neighbor traversal.

class warp.mesh_query_aabb_t#: Object used to track state during mesh traversal.

class warp.mesh_query_point_t#

Output for the mesh query point functions.

result#

Whether a point is found within the given constraints.

Type:: bool

sign#

A value < 0 if query point is inside the mesh, >=0 otherwise. Note that mesh must be watertight for this to be robust

Type:: float32

face#

Index of the closest face.

Type:: int32

u#

Barycentric u coordinate of the closest point.

Type:: float32

v#

Barycentric v coordinate of the closest point.

Type:: float32

Scalar Math#

warp.min(x: Scalar, y: Scalar) → Scalar#: Return the minimum of two scalars.

warp.min(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) → Vector[Any, Scalar]: Return the element-wise minimum of two vectors.

warp.min(v: Vector[Any, Scalar]) → Scalar: Return the minimum element of a vector v.

warp.max(x: Scalar, y: Scalar) → Scalar#: Return the maximum of two scalars.

warp.max(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) → Vector[Any, Scalar]: Return the element-wise maximum of two vectors.

warp.max(v: Vector[Any, Scalar]) → Scalar: Return the maximum element of a vector v.

warp.clamp(x: Scalar, a: Scalar, b: Scalar) → Scalar#: Clamp the value of x to the range [a, b].

warp.abs(x: Scalar) → Scalar#: Return the absolute value of x.

warp.sign(x: Scalar) → Scalar#: Return -1 if x < 0, return 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(x)), 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(x: Scalar) → bool#: Return True if x is a finite number, otherwise return False.

warp.isfinite(x: Vector[Any, Scalar]) → bool: Return True if all elements of the vector x are finite, otherwise return False.

warp.isfinite(x: Quaternion[Scalar]) → bool: Return True if all elements of the quaternion x are finite, otherwise return False.

warp.isfinite(m: Matrix[Any, Any, Scalar]) → bool: Return True if all elements of the matrix m are finite, otherwise return False.

warp.isnan(x: Scalar) → bool#: Return True if x is NaN, otherwise return False.

warp.isnan(x: Vector[Any, Scalar]) → bool: Return True if any element of the vector x is NaN, otherwise return False.

warp.isnan(x: Quaternion[Scalar]) → bool: Return True if any element of the quaternion x is NaN, otherwise return False.

warp.isnan(m: Matrix[Any, Any, Scalar]) → bool: Return True if any element of the matrix m is NaN, otherwise return False.

warp.isinf(x: Scalar) → bool#: Return True if x is positive or negative infinity, otherwise return False.

warp.isinf(x: Vector[Any, Scalar]) → bool: Return True if any element of the vector x is positive or negative infinity, otherwise return False.

warp.isinf(x: Quaternion[Scalar]) → bool: Return True if any element of the quaternion x is positive or negative infinity, otherwise return False.

warp.isinf(m: Matrix[Any, Any, Scalar]) → bool: Return True if any element of the matrix m is positive or negative infinity, otherwise return False.

Vector Math#

warp.dot(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) → Scalar#: Compute the dot product between two vectors.

warp.dot(x: Quaternion[Float], y: Quaternion[Float]) → Scalar: Compute the dot product between two quaternions.

warp.ddot(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) → Scalar#: Compute the double dot product between two matrices.

warp.argmin(v: Vector[Any, Scalar]) → uint32#: Return the index of the minimum element of a vector v. [1]

warp.argmax(v: Vector[Any, Scalar]) → uint32#: Return the index of the maximum element of a vector v. [1]

warp.outer(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) → Matrix[Any, Any, Scalar]#: Compute the outer product x*y^T for two vectors.

warp.cross(x: Vector[3, Scalar], y: Vector[3, Scalar]) → Vector[3, Scalar]#: Compute the cross product of two 3D vectors.

warp.skew(x: Vector[3, Scalar])#: Compute the skew-symmetric 3x3 matrix for a 3D vector x.

warp.length(x: Vector[Any, Float]) → Scalar#: Compute the length of a floating-point vector x.

warp.length(x: Quaternion[Float]) → Scalar: Compute the length of a quaternion x.

warp.length_sq(x: Vector[Any, Scalar]) → Scalar#: Compute the squared length of a vector x.

warp.length_sq(x: Quaternion[Scalar]) → Scalar: Compute the squared length of a quaternion x.

warp.normalize(x: Vector[Any, Float]) → Vector[Any, Scalar]#: Compute the normalized value of x. If length(x) is 0 then the zero vector is returned.

warp.normalize(x: Quaternion[Float]) → Quaternion[Scalar]: Compute the normalized value of x. If length(x) is 0, then the zero quaternion is returned.

warp.transpose(m: Matrix[Any, Any, Scalar])#: Return the transpose of the matrix m.

warp.inverse(m: Matrix[2, 2, Float]) → Matrix[Any, Any, Float]#: Return the inverse of a 2x2 matrix m.

warp.inverse(m: Matrix[3, 3, Float]) → Matrix[Any, Any, Float]: Return the inverse of a 3x3 matrix m.

warp.inverse(m: Matrix[4, 4, Float]) → Matrix[Any, Any, Float]: Return the inverse of a 4x4 matrix m.

warp.determinant(m: Matrix[2, 2, Float]) → Scalar#: Return the determinant of a 2x2 matrix m.

warp.determinant(m: Matrix[3, 3, Float]) → Scalar: Return the determinant of a 3x3 matrix m.

warp.determinant(m: Matrix[4, 4, Float]) → Scalar: Return the determinant of a 4x4 matrix m.

warp.trace(m: Matrix[Any, Any, Scalar]) → Scalar#: Return the trace of the matrix m.

warp.diag(d: Vector[Any, Scalar]) → Matrix[Any, Any, Scalar]#: Returns a matrix with the components of the vector d on the diagonal.

warp.get_diag(m: Matrix[Any, Any, Scalar]) → Vector[Any, Scalar]#: Returns a vector containing the diagonal elements of the square matrix m.

warp.cw_mul(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) → Vector[Any, Scalar]#: Component-wise multiplication of two vectors.

warp.cw_mul(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) → Matrix[Any, Any, Scalar]: Component-wise multiplication of two matrices.

warp.cw_div(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) → Vector[Any, Scalar]#: Component-wise division of two vectors.

warp.cw_div(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) → Matrix[Any, Any, Scalar]: Component-wise division of two matrices.

warp.vector(w: Vector[3, Float], v: Vector[3, Float])#: Construct a 6D screw vector from two 3D vectors.

warp.vector(*arg_types: Scalar, length: int32, dtype: Scalar) → Vector[Any, Scalar]: Construct a vector of with given length and dtype.

warp.matrix(pos: Vector[3, Float], rot: Quaternion[Float], scale: Vector[3, Float]) → Matrix[4, 4, Float]#: Construct a 4x4 transformation matrix that applies the transformations as Translation(pos)*Rotation(rot)*Scale(scale) when applied to column vectors, i.e.: y = (TRS)*x

warp.matrix(*arg_types: 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() → 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(i: Vector[3, Float], r: Float) → Quaternion[Float]: Create a quaternion using the supplied vector/scalar (type inferred from scalar type).

warp.quaternion(q: Quaternion[Float]): Construct a quaternion of type dtype from another quaternion of a different dtype.

warp.quat_identity() → 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[Scalar]#: Construct a quaternion representing a rotation of angle radians around the given axis.

warp.quat_to_axis_angle(q: Quaternion[Float], axis: Vector[3, Float], angle: Float) → None#: Extract the rotation axis and angle radians a quaternion represents.

warp.quat_from_matrix(m: Matrix[3, 3, Float]) → Quaternion[Scalar]#: Construct a quaternion from a 3x3 matrix.

warp.quat_rpy(roll: Float, pitch: Float, yaw: Float) → Quaternion[Scalar]#: Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians.

warp.quat_inverse(q: Quaternion[Float]) → Quaternion[Scalar]#: Compute quaternion conjugate.

warp.quat_rotate(q: Quaternion[Float], p: Vector[3, Float]) → Vector[3, Scalar]#: Rotate a vector by a quaternion.

warp.quat_rotate_inv(q: Quaternion[Float], p: Vector[3, Float]) → Vector[3, Scalar]#: Rotate a vector by the inverse of a quaternion.

warp.quat_slerp(q0: Quaternion[Float], q1: Quaternion[Float], t: Float) → Quaternion[Scalar]#: Linearly interpolate between two quaternions.

warp.quat_to_matrix(q: Quaternion[Float]) → Matrix[3, 3, Scalar]#: Convert a quaternion to a 3x3 rotation matrix.

Transformations#

warp.transformation(p: Vector[3, Float], q: Quaternion[Float]) → Transformation[Scalar]#: Construct a rigid-body transformation with translation part p and rotation q.

warp.transform_identity() → transformf#: Construct an identity transform with zero translation and identity rotation.

warp.transform_get_translation(t: Transformation[Float]) → Vector[3, Scalar]#: Return the translational part of a transform t.

warp.transform_get_rotation(t: Transformation[Float]) → Quaternion[Scalar]#: Return the rotational part of a transform t.

warp.transform_multiply(a: Transformation[Float], b: Transformation[Float]) → Transformation[Scalar]#: Multiply two rigid body transformations together.

warp.transform_point(t: Transformation[Scalar], p: Vector[3, Scalar]) → Vector[3, Scalar]#: Apply the transform to a point p treating the homogeneous coordinate as w=1 (translation and rotation).

warp.transform_point(m: Matrix[4, 4, Scalar], p: Vector[3, Scalar]) → Vector[3, Scalar]

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

The transformation is applied treating p as a column vector, e.g.: y = M*p. Note this is in contrast to some libraries, notably USD, which applies transforms to row vectors, y^T = p^T*M^T. If the transform is coming from a library that uses row-vectors, then users should transpose the transformation matrix before calling this method.

warp.transform_vector(t: Transformation[Scalar], v: Vector[3, Scalar]) → Vector[3, Scalar]#: Apply the transform to a vector v treating the homogeneous coordinate as w=0 (rotation only).

warp.transform_vector(m: Matrix[4, 4, Scalar], v: Vector[3, Scalar]) → Vector[3, Scalar]

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

The transformation is applied treating v as a column vector, e.g.: y = M*v note this is in contrast to some libraries, notably USD, which applies transforms to row vectors, y^T = v^T*M^T. If the transform is coming from a library that uses row-vectors, then users should transpose the transformation matrix before calling this method.

warp.transform_inverse(t: Transformation[Float]) → Transformation[Float]#: Compute the inverse of the transformation t.

Spatial Math#

warp.spatial_adjoint(r: Matrix[3, 3, Float], s: Matrix[3, 3, Float]) → Matrix[6, 6, Scalar]#: Construct a 6x6 spatial inertial matrix from two 3x3 diagonal blocks.

warp.spatial_dot(a: Vector[6, Float], b: Vector[6, Float]) → Scalar#: 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(a: Vector[6, Float])#: Return the top (first) part of a 6D screw vector.

warp.spatial_bottom(a: Vector[6, 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() → 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, arg1: Any, arg2: Any)#: Select between two arguments, if cond is False then return arg1, otherwise return arg2

warp.select(cond: int8, arg1: Any, arg2: Any): Select between two arguments, if cond is False then return arg1, otherwise return arg2

warp.select(cond: uint8, arg1: Any, arg2: Any): Select between two arguments, if cond is False then return arg1, otherwise return arg2

warp.select(cond: int16, arg1: Any, arg2: Any): Select between two arguments, if cond is False then return arg1, otherwise return arg2

warp.select(cond: uint16, arg1: Any, arg2: Any): Select between two arguments, if cond is False then return arg1, otherwise return arg2

warp.select(cond: int32, arg1: Any, arg2: Any): Select between two arguments, if cond is False then return arg1, otherwise return arg2

warp.select(cond: uint32, arg1: Any, arg2: Any): Select between two arguments, if cond is False then return arg1, otherwise return arg2

warp.select(cond: int64, arg1: Any, arg2: Any): Select between two arguments, if cond is False then return arg1, otherwise return arg2

warp.select(cond: uint64, arg1: Any, arg2: Any): Select between two arguments, if cond is False then return arg1, otherwise return arg2

warp.select(arr: Array[Any], arg1: Any, arg2: Any): Select between two arguments, if arr is null then return arg1, otherwise return arg2

warp.atomic_add(a: Array[Any], i: int32, value: Any)#: Atomically add value onto a[i].

warp.atomic_add(a: Array[Any], i: int32, j: int32, value: Any): Atomically add value onto a[i,j].

warp.atomic_add(a: Array[Any], i: int32, j: int32, k: int32, value: Any): Atomically add value onto a[i,j,k].

warp.atomic_add(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any): Atomically add value onto a[i,j,k,l].

warp.atomic_add(a: FabricArray[Any], i: int32, value: Any): Atomically add value onto a[i].

warp.atomic_add(a: FabricArray[Any], i: int32, j: int32, value: Any): Atomically add value onto a[i,j].

warp.atomic_add(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any): Atomically add value onto a[i,j,k].

warp.atomic_add(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): Atomically add value onto a[i,j,k,l].

warp.atomic_add(a: IndexedFabricArray[Any], i: int32, value: Any): Atomically add value onto a[i].

warp.atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any): Atomically add value onto a[i,j].

warp.atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any): Atomically add value onto a[i,j,k].

warp.atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): Atomically add value onto a[i,j,k,l].

warp.atomic_sub(a: Array[Any], i: int32, value: Any)#: Atomically subtract value onto a[i].

warp.atomic_sub(a: Array[Any], i: int32, j: int32, value: Any): Atomically subtract value onto a[i,j].

warp.atomic_sub(a: Array[Any], i: int32, j: int32, k: int32, value: Any): Atomically subtract value onto a[i,j,k].

warp.atomic_sub(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any): Atomically subtract value onto a[i,j,k,l].

warp.atomic_sub(a: FabricArray[Any], i: int32, value: Any): Atomically subtract value onto a[i].

warp.atomic_sub(a: FabricArray[Any], i: int32, j: int32, value: Any): Atomically subtract value onto a[i,j].

warp.atomic_sub(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any): Atomically subtract value onto a[i,j,k].

warp.atomic_sub(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): Atomically subtract value onto a[i,j,k,l].

warp.atomic_sub(a: IndexedFabricArray[Any], i: int32, value: Any): Atomically subtract value onto a[i].

warp.atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any): Atomically subtract value onto a[i,j].

warp.atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any): Atomically subtract value onto a[i,j,k].

warp.atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): Atomically subtract value onto a[i,j,k,l].

warp.atomic_min(a: Array[Any], i: int32, value: Any)#: Compute the minimum of value and a[i] and atomically update the array.

Note

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

warp.atomic_min(a: Array[Any], i: int32, j: int32, value: Any): Compute the minimum of value and a[i,j] and atomically update the array.

Note

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

warp.atomic_min(a: Array[Any], i: int32, j: int32, k: int32, value: Any): Compute the minimum of value and a[i,j,k] and atomically update the array.

Note

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

warp.atomic_min(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any): Compute the minimum of value and a[i,j,k,l] and atomically update the array.

Note

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

warp.atomic_min(a: FabricArray[Any], i: int32, value: Any): Compute the minimum of value and a[i] and atomically update the array.

Note

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

warp.atomic_min(a: FabricArray[Any], i: int32, j: int32, value: Any): Compute the minimum of value and a[i,j] and atomically update the array.

Note

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

warp.atomic_min(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any): Compute the minimum of value and a[i,j,k] and atomically update the array.

Note

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

warp.atomic_min(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): Compute the minimum of value and a[i,j,k,l] and atomically update the array.

Note

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

warp.atomic_min(a: IndexedFabricArray[Any], i: int32, value: Any): Compute the minimum of value and a[i] and atomically update the array.

Note

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

warp.atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any): Compute the minimum of value and a[i,j] and atomically update the array.

Note

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

warp.atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any): Compute the minimum of value and a[i,j,k] and atomically update the array.

Note

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

warp.atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): Compute the minimum of value and a[i,j,k,l] and atomically update the array.

Note

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

warp.atomic_max(a: Array[Any], i: int32, value: Any)#: Compute the maximum of value and a[i] and atomically update the array.

Note

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

warp.atomic_max(a: Array[Any], i: int32, j: int32, value: Any): Compute the maximum of value and a[i,j] and atomically update the array.

Note

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

warp.atomic_max(a: Array[Any], i: int32, j: int32, k: int32, value: Any): Compute the maximum of value and a[i,j,k] and atomically update the array.

Note

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

warp.atomic_max(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any): Compute the maximum of value and a[i,j,k,l] and atomically update the array.

Note

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

warp.atomic_max(a: FabricArray[Any], i: int32, value: Any): Compute the maximum of value and a[i] and atomically update the array.

Note

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

warp.atomic_max(a: FabricArray[Any], i: int32, j: int32, value: Any): Compute the maximum of value and a[i,j] and atomically update the array.

Note

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

warp.atomic_max(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any): Compute the maximum of value and a[i,j,k] and atomically update the array.

Note

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

warp.atomic_max(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): Compute the maximum of value and a[i,j,k,l] and atomically update the array.

Note

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

warp.atomic_max(a: IndexedFabricArray[Any], i: int32, value: Any): Compute the maximum of value and a[i] and atomically update the array.

Note

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

warp.atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any): Compute the maximum of value and a[i,j] and atomically update the array.

Note

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

warp.atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any): Compute the maximum of value and a[i,j,k] and atomically update the array.

Note

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

warp.atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): Compute the maximum of value and a[i,j,k,l] and atomically update the array.

Note

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

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(edge0: Float, edge1: Float, x: Float) → Float#: Smoothly interpolate between two values edge0 and edge1 using a factor x, and return a result between 0 and 1 using a cubic Hermite interpolation after clamping.

warp.expect_near(arg1: Float, arg2: Float, tolerance: Float) → None#: Prints an error to stdout if arg1 and arg2 are not closer than tolerance in magnitude

warp.expect_near(arg1: vec3f, arg2: vec3f, tolerance: float32) → None: Prints an error to stdout if any element of arg1 and arg2 are not closer than tolerance in magnitude

Geometry#

warp.bvh_query_aabb(id: uint64, lower: vec3f, upper: vec3f) → bvh_query_t#

Construct an axis-aligned bounding box query against a BVH object.

This query can be used to iterate over all bounds inside a BVH.

Parameters:

id – The BVH identifier
lower – The lower bound of the bounding box in BVH space
upper – 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.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.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.mesh_query_aabb(id: uint64, lower: vec3f, upper: 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
lower – The lower bound of the bounding box in mesh space
upper – 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.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_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_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, min: int32, max: int32) → int: Return a random integer between [min, max).

warp.randf(state: uint32) → float#: Return a random float between [0.0, 1.0).

warp.randf(state: uint32, min: float32, max: float32) → float: Return a random float between [min, max).

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(x: Int, y: Int) → Int#

warp.bit_or(x: Int, y: Int) → Int#

warp.bit_xor(x: Int, y: Int) → Int#

warp.lshift(x: Int, y: Int) → Int#

warp.rshift(x: Int, y: Int) → Int#

warp.invert(x: Int) → Int#

Operators#

warp.add(x: Scalar, y: Scalar) → Scalar#

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

warp.add(x: Quaternion[Scalar], y: Quaternion[Scalar]) → Quaternion[Scalar]

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

warp.add(x: Transformation[Scalar], y: Transformation[Scalar]) → Transformation[Scalar]

warp.sub(x: Scalar, y: Scalar) → Scalar#

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

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

warp.sub(x: Quaternion[Scalar], y: Quaternion[Scalar]) → Quaternion[Scalar]

warp.sub(x: Transformation[Scalar], y: Transformation[Scalar]) → Transformation[Scalar]

warp.mul(x: Scalar, y: Scalar) → Scalar#

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

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

warp.mul(x: Quaternion[Scalar], y: Scalar) → Quaternion[Scalar]

warp.mul(x: Scalar, y: Quaternion[Scalar]) → Quaternion[Scalar]

warp.mul(x: Quaternion[Scalar], y: Quaternion[Scalar]) → Quaternion[Scalar]

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

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

warp.mul(x: Matrix[Any, Any, Scalar], y: Vector[Any, Scalar]) → Vector[Any, Scalar]

warp.mul(x: Vector[Any, Scalar], y: Matrix[Any, Any, Scalar]) → Vector[Any, Scalar]

warp.mul(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar])

warp.mul(x: Transformation[Scalar], y: Transformation[Scalar]) → Transformation[Scalar]

warp.mul(x: Scalar, y: Transformation[Scalar]) → Transformation[Scalar]

warp.mul(x: Transformation[Scalar], y: Scalar) → Transformation[Scalar]

warp.mod(x: Scalar, y: Scalar) → Scalar#

warp.div(x: Scalar, y: Scalar) → Scalar#

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

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

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

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

warp.div(x: Quaternion[Scalar], y: Scalar) → Quaternion[Scalar]

warp.div(x: Scalar, y: Quaternion[Scalar]) → Quaternion[Scalar]

warp.floordiv(x: Scalar, y: 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(b: bool) → bool#

warp.unot(b: int8) → bool

warp.unot(b: uint8) → bool

warp.unot(b: int16) → bool

warp.unot(b: uint16) → bool

warp.unot(b: int32) → bool

warp.unot(b: uint32) → bool

warp.unot(b: int64) → bool

warp.unot(b: uint64) → bool

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

Footnotes