Spaces:
Sleeping
Sleeping
| # Autogenerated file, do not edit, this file provides stubs for builtins autocomplete in VSCode, PyCharm, etc | |
| from typing import Any | |
| from typing import Tuple | |
| from typing import Callable | |
| from typing import TypeVar | |
| from typing import Generic | |
| from typing import overload as over | |
| Length = TypeVar("Length", bound=int) | |
| Rows = TypeVar("Rows", bound=int) | |
| Cols = TypeVar("Cols", bound=int) | |
| DType = TypeVar("DType") | |
| Int = TypeVar("Int") | |
| Float = TypeVar("Float") | |
| Scalar = TypeVar("Scalar") | |
| Vector = Generic[Length, Scalar] | |
| Matrix = Generic[Rows, Cols, Scalar] | |
| Quaternion = Generic[Float] | |
| Transformation = Generic[Float] | |
| Array = Generic[DType] | |
| FabricArray = Generic[DType] | |
| IndexedFabricArray = Generic[DType] | |
| from warp.types import array, array1d, array2d, array3d, array4d, constant | |
| from warp.types import indexedarray, indexedarray1d, indexedarray2d, indexedarray3d, indexedarray4d | |
| from warp.fabric import fabricarray, fabricarrayarray, indexedfabricarray, indexedfabricarrayarray | |
| from warp.types import bool, int8, uint8, int16, uint16, int32, uint32, int64, uint64, float16, float32, float64 | |
| from warp.types import vec2, vec2b, vec2ub, vec2s, vec2us, vec2i, vec2ui, vec2l, vec2ul, vec2h, vec2f, vec2d | |
| from warp.types import vec3, vec3b, vec3ub, vec3s, vec3us, vec3i, vec3ui, vec3l, vec3ul, vec3h, vec3f, vec3d | |
| from warp.types import vec4, vec4b, vec4ub, vec4s, vec4us, vec4i, vec4ui, vec4l, vec4ul, vec4h, vec4f, vec4d | |
| from warp.types import mat22, mat22h, mat22f, mat22d | |
| from warp.types import mat33, mat33h, mat33f, mat33d | |
| from warp.types import mat44, mat44h, mat44f, mat44d | |
| from warp.types import quat, quath, quatf, quatd | |
| from warp.types import transform, transformh, transformf, transformd | |
| from warp.types import spatial_vector, spatial_vectorh, spatial_vectorf, spatial_vectord | |
| from warp.types import spatial_matrix, spatial_matrixh, spatial_matrixf, spatial_matrixd | |
| from warp.types import Bvh, Mesh, HashGrid, Volume, MarchingCubes | |
| from warp.types import bvh_query_t, hash_grid_query_t, mesh_query_aabb_t, mesh_query_point_t, mesh_query_ray_t | |
| from warp.types import matmul, adj_matmul, batched_matmul, adj_batched_matmul, from_ptr | |
| from warp.types import vector as vec | |
| from warp.types import matrix as mat | |
| from warp.context import init, func, func_grad, func_replay, func_native, kernel, struct, overload | |
| from warp.context import is_cpu_available, is_cuda_available, is_device_available | |
| from warp.context import get_devices, get_preferred_device | |
| from warp.context import get_cuda_devices, get_cuda_device_count, get_cuda_device, map_cuda_device, unmap_cuda_device | |
| from warp.context import get_device, set_device, synchronize_device | |
| from warp.context import ( | |
| zeros, | |
| zeros_like, | |
| full, | |
| full_like, | |
| clone, | |
| empty, | |
| empty_like, | |
| copy, | |
| from_numpy, | |
| launch, | |
| synchronize, | |
| force_load, | |
| load_module, | |
| ) | |
| from warp.context import set_module_options, get_module_options, get_module | |
| from warp.context import capture_begin, capture_end, capture_launch | |
| from warp.context import Kernel, Function, Launch | |
| from warp.context import Stream, get_stream, set_stream, synchronize_stream | |
| from warp.context import Event, record_event, wait_event, wait_stream | |
| from warp.context import RegisteredGLBuffer | |
| from warp.tape import Tape | |
| from warp.utils import ScopedTimer, ScopedDevice, ScopedStream | |
| from warp.utils import transform_expand, quat_between_vectors | |
| from warp.torch import from_torch, to_torch | |
| from warp.torch import device_from_torch, device_to_torch | |
| from warp.torch import stream_from_torch, stream_to_torch | |
| from warp.jax import from_jax, to_jax | |
| from warp.jax import device_from_jax, device_to_jax | |
| from warp.dlpack import from_dlpack, to_dlpack | |
| from warp.constants import * | |
| from . import builtins | |
| import warp.config | |
| __version__ = warp.config.version | |
| def min(x: Scalar, y: Scalar) -> Scalar: | |
| """ | |
| Return the minimum of two scalars. | |
| """ | |
| ... | |
| def min(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]: | |
| """ | |
| Return the element-wise minimum of two vectors. | |
| """ | |
| ... | |
| def min(v: Vector[Any, Scalar]) -> Scalar: | |
| """ | |
| Return the minimum element of a vector ``v``. | |
| """ | |
| ... | |
| def max(x: Scalar, y: Scalar) -> Scalar: | |
| """ | |
| Return the maximum of two scalars. | |
| """ | |
| ... | |
| def max(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]: | |
| """ | |
| Return the element-wise maximum of two vectors. | |
| """ | |
| ... | |
| def max(v: Vector[Any, Scalar]) -> Scalar: | |
| """ | |
| Return the maximum element of a vector ``v``. | |
| """ | |
| ... | |
| def clamp(x: Scalar, a: Scalar, b: Scalar) -> Scalar: | |
| """ | |
| Clamp the value of ``x`` to the range [a, b]. | |
| """ | |
| ... | |
| def abs(x: Scalar) -> Scalar: | |
| """ | |
| Return the absolute value of ``x``. | |
| """ | |
| ... | |
| def sign(x: Scalar) -> Scalar: | |
| """ | |
| Return -1 if ``x`` < 0, return 1 otherwise. | |
| """ | |
| ... | |
| def step(x: Scalar) -> Scalar: | |
| """ | |
| Return 1.0 if ``x`` < 0.0, return 0.0 otherwise. | |
| """ | |
| ... | |
| def nonzero(x: Scalar) -> Scalar: | |
| """ | |
| Return 1.0 if ``x`` is not equal to zero, return 0.0 otherwise. | |
| """ | |
| ... | |
| def sin(x: Float) -> Float: | |
| """ | |
| Return the sine of ``x`` in radians. | |
| """ | |
| ... | |
| def cos(x: Float) -> Float: | |
| """ | |
| Return the cosine of ``x`` in radians. | |
| """ | |
| ... | |
| def acos(x: Float) -> Float: | |
| """ | |
| Return arccos of ``x`` in radians. Inputs are automatically clamped to [-1.0, 1.0]. | |
| """ | |
| ... | |
| def asin(x: Float) -> Float: | |
| """ | |
| Return arcsin of ``x`` in radians. Inputs are automatically clamped to [-1.0, 1.0]. | |
| """ | |
| ... | |
| def sqrt(x: Float) -> Float: | |
| """ | |
| Return the square root of ``x``, where ``x`` is positive. | |
| """ | |
| ... | |
| def cbrt(x: Float) -> Float: | |
| """ | |
| Return the cube root of ``x``. | |
| """ | |
| ... | |
| def tan(x: Float) -> Float: | |
| """ | |
| Return the tangent of ``x`` in radians. | |
| """ | |
| ... | |
| def atan(x: Float) -> Float: | |
| """ | |
| Return the arctangent of ``x`` in radians. | |
| """ | |
| ... | |
| def atan2(y: Float, x: Float) -> Float: | |
| """ | |
| Return the 2-argument arctangent, atan2, of the point ``(x, y)`` in radians. | |
| """ | |
| ... | |
| def sinh(x: Float) -> Float: | |
| """ | |
| Return the sinh of ``x``. | |
| """ | |
| ... | |
| def cosh(x: Float) -> Float: | |
| """ | |
| Return the cosh of ``x``. | |
| """ | |
| ... | |
| def tanh(x: Float) -> Float: | |
| """ | |
| Return the tanh of ``x``. | |
| """ | |
| ... | |
| def degrees(x: Float) -> Float: | |
| """ | |
| Convert ``x`` from radians into degrees. | |
| """ | |
| ... | |
| def radians(x: Float) -> Float: | |
| """ | |
| Convert ``x`` from degrees into radians. | |
| """ | |
| ... | |
| def log(x: Float) -> Float: | |
| """ | |
| Return the natural logarithm (base-e) of ``x``, where ``x`` is positive. | |
| """ | |
| ... | |
| def log2(x: Float) -> Float: | |
| """ | |
| Return the binary logarithm (base-2) of ``x``, where ``x`` is positive. | |
| """ | |
| ... | |
| def log10(x: Float) -> Float: | |
| """ | |
| Return the common logarithm (base-10) of ``x``, where ``x`` is positive. | |
| """ | |
| ... | |
| def exp(x: Float) -> Float: | |
| """ | |
| Return the value of the exponential function :math:`e^x`. | |
| """ | |
| ... | |
| def pow(x: Float, y: Float) -> Float: | |
| """ | |
| Return the result of ``x`` raised to power of ``y``. | |
| """ | |
| ... | |
| def round(x: Float) -> Float: | |
| """ | |
| Return the nearest integer value to ``x``, rounding halfway cases away from zero. | |
| This is the most intuitive form of rounding in the colloquial sense, but can be slower than other options like :func:`warp.rint()`. | |
| Differs from :func:`numpy.round()`, which behaves the same way as :func:`numpy.rint()`. | |
| """ | |
| ... | |
| def rint(x: Float) -> Float: | |
| """ | |
| Return the nearest integer value to ``x``, rounding halfway cases to nearest even integer. | |
| It is generally faster than :func:`warp.round()`. Equivalent to :func:`numpy.rint()`. | |
| """ | |
| ... | |
| def trunc(x: Float) -> Float: | |
| """ | |
| Return the nearest integer that is closer to zero than ``x``. | |
| In other words, it discards the fractional part of ``x``. | |
| It is similar to casting ``float(int(x))``, but preserves the negative sign when x is in the range [-0.0, -1.0). | |
| Equivalent to :func:`numpy.trunc()` and :func:`numpy.fix()`. | |
| """ | |
| ... | |
| def floor(x: Float) -> Float: | |
| """ | |
| Return the largest integer that is less than or equal to ``x``. | |
| """ | |
| ... | |
| def ceil(x: Float) -> Float: | |
| """ | |
| Return the smallest integer that is greater than or equal to ``x``. | |
| """ | |
| ... | |
| def frac(x: Float) -> Float: | |
| """ | |
| Retrieve the fractional part of x. | |
| In other words, it discards the integer part of x and is equivalent to ``x - trunc(x)``. | |
| """ | |
| ... | |
| def dot(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Scalar: | |
| """ | |
| Compute the dot product between two vectors. | |
| """ | |
| ... | |
| def dot(x: Quaternion[Float], y: Quaternion[Float]) -> Scalar: | |
| """ | |
| Compute the dot product between two quaternions. | |
| """ | |
| ... | |
| def ddot(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Scalar: | |
| """ | |
| Compute the double dot product between two matrices. | |
| """ | |
| ... | |
| def argmin(v: Vector[Any, Scalar]) -> uint32: | |
| """ | |
| Return the index of the minimum element of a vector ``v``. | |
| """ | |
| ... | |
| def argmax(v: Vector[Any, Scalar]) -> uint32: | |
| """ | |
| Return the index of the maximum element of a vector ``v``. | |
| """ | |
| ... | |
| def outer(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Matrix[Any, Any, Scalar]: | |
| """ | |
| Compute the outer product ``x*y^T`` for two vectors. | |
| """ | |
| ... | |
| def cross(x: Vector[3, Scalar], y: Vector[3, Scalar]) -> Vector[3, Scalar]: | |
| """ | |
| Compute the cross product of two 3D vectors. | |
| """ | |
| ... | |
| def skew(x: Vector[3, Scalar]): | |
| """ | |
| Compute the skew-symmetric 3x3 matrix for a 3D vector ``x``. | |
| """ | |
| ... | |
| def length(x: Vector[Any, Float]) -> Scalar: | |
| """ | |
| Compute the length of a vector ``x``. | |
| """ | |
| ... | |
| def length(x: Quaternion[Float]) -> Scalar: | |
| """ | |
| Compute the length of a quaternion ``x``. | |
| """ | |
| ... | |
| def length_sq(x: Vector[Any, Scalar]) -> Scalar: | |
| """ | |
| Compute the squared length of a 2D vector ``x``. | |
| """ | |
| ... | |
| def length_sq(x: Quaternion[Scalar]) -> Scalar: | |
| """ | |
| Compute the squared length of a quaternion ``x``. | |
| """ | |
| ... | |
| def normalize(x: Vector[Any, Float]) -> Vector[Any, Scalar]: | |
| """ | |
| Compute the normalized value of ``x``. If ``length(x)`` is 0 then the zero vector is returned. | |
| """ | |
| ... | |
| def normalize(x: Quaternion[Float]) -> Quaternion[Scalar]: | |
| """ | |
| Compute the normalized value of ``x``. If ``length(x)`` is 0, then the zero quaternion is returned. | |
| """ | |
| ... | |
| def transpose(m: Matrix[Any, Any, Scalar]): | |
| """ | |
| Return the transpose of the matrix ``m``. | |
| """ | |
| ... | |
| def inverse(m: Matrix[2, 2, Float]) -> Matrix[Any, Any, Float]: | |
| """ | |
| Return the inverse of a 2x2 matrix ``m``. | |
| """ | |
| ... | |
| def inverse(m: Matrix[3, 3, Float]) -> Matrix[Any, Any, Float]: | |
| """ | |
| Return the inverse of a 3x3 matrix ``m``. | |
| """ | |
| ... | |
| def inverse(m: Matrix[4, 4, Float]) -> Matrix[Any, Any, Float]: | |
| """ | |
| Return the inverse of a 4x4 matrix ``m``. | |
| """ | |
| ... | |
| def determinant(m: Matrix[2, 2, Float]) -> Scalar: | |
| """ | |
| Return the determinant of a 2x2 matrix ``m``. | |
| """ | |
| ... | |
| def determinant(m: Matrix[3, 3, Float]) -> Scalar: | |
| """ | |
| Return the determinant of a 3x3 matrix ``m``. | |
| """ | |
| ... | |
| def determinant(m: Matrix[4, 4, Float]) -> Scalar: | |
| """ | |
| Return the determinant of a 4x4 matrix ``m``. | |
| """ | |
| ... | |
| def trace(m: Matrix[Any, Any, Scalar]) -> Scalar: | |
| """ | |
| Return the trace of the matrix ``m``. | |
| """ | |
| ... | |
| def diag(d: Vector[Any, Scalar]) -> Matrix[Any, Any, Scalar]: | |
| """ | |
| Returns a matrix with the components of the vector ``d`` on the diagonal. | |
| """ | |
| ... | |
| def get_diag(m: Matrix[Any, Any, Scalar]) -> Vector[Any, Scalar]: | |
| """ | |
| Returns a vector containing the diagonal elements of the square matrix ``m``. | |
| """ | |
| ... | |
| def get_diag(m: Matrix[Any, Any, Scalar]) -> Vector[Any, Scalar]: | |
| """ | |
| Returns a vector containing the diagonal elements of the square matrix. | |
| """ | |
| ... | |
| def cw_mul(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]: | |
| """ | |
| Component-wise multiplication of two 2D vectors. | |
| """ | |
| ... | |
| def cw_mul(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]: | |
| """ | |
| Component-wise multiplication of two 2D vectors. | |
| """ | |
| ... | |
| def cw_div(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]: | |
| """ | |
| Component-wise division of two 2D vectors. | |
| """ | |
| ... | |
| def cw_div(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]: | |
| """ | |
| Component-wise division of two 2D vectors. | |
| """ | |
| ... | |
| def quat_identity() -> quatf: | |
| """ | |
| Construct an identity quaternion with zero imaginary part and real part of 1.0 | |
| """ | |
| ... | |
| def quat_from_axis_angle(axis: Vector[3, Float], angle: Float) -> Quaternion[Scalar]: | |
| """ | |
| Construct a quaternion representing a rotation of angle radians around the given axis. | |
| """ | |
| ... | |
| def quat_to_axis_angle(q: Quaternion[Float], axis: Vector[3, Float], angle: Float): | |
| """ | |
| Extract the rotation axis and angle radians a quaternion represents. | |
| """ | |
| ... | |
| def quat_from_matrix(m: Matrix[3, 3, Float]) -> Quaternion[Scalar]: | |
| """ | |
| Construct a quaternion from a 3x3 matrix. | |
| """ | |
| ... | |
| def quat_rpy(roll: Float, pitch: Float, yaw: Float) -> Quaternion[Scalar]: | |
| """ | |
| Construct a quaternion representing a combined roll (z), pitch (x), yaw rotations (y) in radians. | |
| """ | |
| ... | |
| def quat_inverse(q: Quaternion[Float]) -> Quaternion[Scalar]: | |
| """ | |
| Compute quaternion conjugate. | |
| """ | |
| ... | |
| def quat_rotate(q: Quaternion[Float], p: Vector[3, Float]) -> Vector[3, Scalar]: | |
| """ | |
| Rotate a vector by a quaternion. | |
| """ | |
| ... | |
| def quat_rotate_inv(q: Quaternion[Float], p: Vector[3, Float]) -> Vector[3, Scalar]: | |
| """ | |
| Rotate a vector by the inverse of a quaternion. | |
| """ | |
| ... | |
| def quat_slerp(q0: Quaternion[Float], q1: Quaternion[Float], t: Float) -> Quaternion[Scalar]: | |
| """ | |
| Linearly interpolate between two quaternions. | |
| """ | |
| ... | |
| def quat_to_matrix(q: Quaternion[Float]) -> Matrix[3, 3, Scalar]: | |
| """ | |
| Convert a quaternion to a 3x3 rotation matrix. | |
| """ | |
| ... | |
| def transform_identity() -> transformf: | |
| """ | |
| Construct an identity transform with zero translation and identity rotation. | |
| """ | |
| ... | |
| def transform_get_translation(t: Transformation[Float]) -> Vector[3, Scalar]: | |
| """ | |
| Return the translational part of a transform ``t``. | |
| """ | |
| ... | |
| def transform_get_rotation(t: Transformation[Float]) -> Quaternion[Scalar]: | |
| """ | |
| Return the rotational part of a transform ``t``. | |
| """ | |
| ... | |
| def transform_multiply(a: Transformation[Float], b: Transformation[Float]) -> Transformation[Scalar]: | |
| """ | |
| Multiply two rigid body transformations together. | |
| """ | |
| ... | |
| def transform_point(t: Transformation[Scalar], p: Vector[3, Scalar]) -> Vector[3, Scalar]: | |
| """ | |
| Apply the transform to a point ``p`` treating the homogenous coordinate as w=1 (translation and rotation). | |
| """ | |
| ... | |
| def transform_point(m: Matrix[4, 4, Scalar], p: Vector[3, Scalar]) -> Vector[3, Scalar]: | |
| """ | |
| Apply the transform to a point ``p`` treating the homogenous 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. | |
| """ | |
| ... | |
| def transform_vector(t: Transformation[Scalar], v: Vector[3, Scalar]) -> Vector[3, Scalar]: | |
| """ | |
| Apply the transform to a vector ``v`` treating the homogenous coordinate as w=0 (rotation only). | |
| """ | |
| ... | |
| def transform_vector(m: Matrix[4, 4, Scalar], v: Vector[3, Scalar]) -> Vector[3, Scalar]: | |
| """ | |
| Apply the transform to a vector ``v`` treating the homogenous 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. | |
| """ | |
| ... | |
| def transform_inverse(t: Transformation[Float]) -> Transformation[Float]: | |
| """ | |
| Compute the inverse of the transformation ``t``. | |
| """ | |
| ... | |
| def spatial_dot(a: Vector[6, Float], b: Vector[6, Float]) -> Scalar: | |
| """ | |
| Compute the dot product of two 6D screw vectors. | |
| """ | |
| ... | |
| def spatial_cross(a: Vector[6, Float], b: Vector[6, Float]) -> Vector[6, Float]: | |
| """ | |
| Compute the cross product of two 6D screw vectors. | |
| """ | |
| ... | |
| def spatial_cross_dual(a: Vector[6, Float], b: Vector[6, Float]) -> Vector[6, Float]: | |
| """ | |
| Compute the dual cross product of two 6D screw vectors. | |
| """ | |
| ... | |
| def spatial_top(a: Vector[6, Float]): | |
| """ | |
| Return the top (first) part of a 6D screw vector. | |
| """ | |
| ... | |
| def spatial_bottom(a: Vector[6, Float]): | |
| """ | |
| Return the bottom (second) part of a 6D screw vector. | |
| """ | |
| ... | |
| def spatial_jacobian( | |
| S: Array[Vector[6, Float]], | |
| joint_parents: Array[int32], | |
| joint_qd_start: Array[int32], | |
| joint_start: int32, | |
| joint_count: int32, | |
| J_start: int32, | |
| J_out: Array[Float], | |
| ): | |
| """ """ | |
| ... | |
| def spatial_mass( | |
| I_s: Array[Matrix[6, 6, Float]], joint_start: int32, joint_count: int32, M_start: int32, M: Array[Float] | |
| ): | |
| """ """ | |
| ... | |
| def mlp( | |
| weights: Array[float32], | |
| bias: Array[float32], | |
| activation: Callable, | |
| index: int32, | |
| x: Array[float32], | |
| out: Array[float32], | |
| ): | |
| """ | |
| Evaluate a multi-layer perceptron (MLP) layer in the form: ``out = act(weights*x + bias)``. | |
| :param weights: A layer's network weights with dimensions ``(m, n)``. | |
| :param bias: An array with dimensions ``(n)``. | |
| :param activation: A ``wp.func`` function that takes a single scalar float as input and returns a scalar float as output | |
| :param index: The batch item to process, typically each thread will process one item in the batch, in which case | |
| index should be ``wp.tid()`` | |
| :param x: The feature matrix with dimensions ``(n, b)`` | |
| :param out: The network output with dimensions ``(m, b)`` | |
| :note: Feature and output matrices are transposed compared to some other frameworks such as PyTorch. | |
| All matrices are assumed to be stored in flattened row-major memory layout (NumPy default). | |
| """ | |
| ... | |
| def bvh_query_aabb(id: uint64, lower: vec3f, upper: vec3f) -> bvh_query_t: | |
| """ | |
| Construct an axis-aligned bounding box query against a BVH object. This query can be used to iterate over all bounds | |
| inside a BVH. | |
| :param id: The BVH identifier | |
| :param lower: The lower bound of the bounding box in BVH space | |
| :param upper: The upper bound of the bounding box in BVH space | |
| """ | |
| ... | |
| def bvh_query_ray(id: uint64, start: vec3f, dir: vec3f) -> bvh_query_t: | |
| """ | |
| Construct a ray query against a BVH object. This query can be used to iterate over all bounds | |
| that intersect the ray. | |
| :param id: The BVH identifier | |
| :param start: The start of the ray in BVH space | |
| :param dir: The direction of the ray in BVH space | |
| """ | |
| ... | |
| def bvh_query_next(query: bvh_query_t, index: int32) -> bool: | |
| """ | |
| Move to the next bound returned by the query. | |
| The index of the current bound is stored in ``index``, returns ``False`` if there are no more overlapping bound. | |
| """ | |
| ... | |
| def mesh_query_point(id: uint64, point: vec3f, max_dist: float32) -> mesh_query_point_t: | |
| """ | |
| Computes the closest point on the :class:`Mesh` with identifier ``id`` to the given ``point`` in space. | |
| Identifies the sign of the distance using additional ray-casts to determine if the point is inside or outside. | |
| This method is relatively robust, but does increase computational cost. | |
| See below for additional sign determination methods. | |
| Identifies the sign of the distance using additional ray-casts to determine if the point is inside or outside. This method is relatively robust, but | |
| does increase computational cost. See below for additional sign determination methods. | |
| :param id: The mesh identifier | |
| :param point: The point in space to query | |
| :param max_dist: Mesh faces above this distance will not be considered by the query | |
| """ | |
| ... | |
| def mesh_query_point_no_sign(id: uint64, point: vec3f, max_dist: float32) -> mesh_query_point_t: | |
| """ | |
| Computes the closest point on the :class:`Mesh` with identifier ``id`` to the given ``point`` in space. | |
| This method does not compute the sign of the point (inside/outside) which makes it faster than other point query methods. | |
| :param id: The mesh identifier | |
| :param point: The point in space to query | |
| :param max_dist: Mesh faces above this distance will not be considered by the query | |
| """ | |
| ... | |
| def mesh_query_furthest_point_no_sign(id: uint64, point: vec3f, min_dist: float32) -> mesh_query_point_t: | |
| """ | |
| Computes the furthest point on the mesh with identifier `id` to the given point in space. | |
| This method does not compute the sign of the point (inside/outside). | |
| :param id: The mesh identifier | |
| :param point: The point in space to query | |
| :param min_dist: Mesh faces below this distance will not be considered by the query | |
| """ | |
| ... | |
| def mesh_query_point_sign_normal(id: uint64, point: vec3f, max_dist: float32, epsilon: float32) -> mesh_query_point_t: | |
| """ | |
| Computes the closest point on the :class:`Mesh` with identifier ``id`` to the given ``point`` in space. | |
| Identifies the sign of the distance (inside/outside) using the angle-weighted pseudo normal. | |
| This approach to sign determination is robust for well conditioned meshes that are watertight and non-self intersecting. | |
| It is also comparatively fast to compute. | |
| :param id: The mesh identifier | |
| :param point: The point in space to query | |
| :param max_dist: Mesh faces above this distance will not be considered by the query | |
| :param epsilon: Epsilon treating distance values as equal, when locating the minimum distance vertex/face/edge, as a | |
| fraction of the average edge length, also for treating closest point as being on edge/vertex default 1e-3 | |
| """ | |
| ... | |
| def mesh_query_point_sign_winding_number( | |
| id: uint64, point: vec3f, max_dist: float32, accuracy: float32, threshold: float32 | |
| ) -> mesh_query_point_t: | |
| """ | |
| Computes the closest point on the :class:`Mesh` with identifier ``id`` to the given point in space. | |
| Identifies the sign using the winding number of the mesh relative to the query point. This method of sign determination is robust for poorly conditioned meshes | |
| and provides a smooth approximation to sign even when the mesh is not watertight. This method is the most robust and accurate of the sign determination meshes | |
| but also the most expensive. | |
| .. note:: The :class:`Mesh` object must be constructed with ``support_winding_number=True`` for this method to return correct results. | |
| :param id: The mesh identifier | |
| :param point: The point in space to query | |
| :param max_dist: Mesh faces above this distance will not be considered by the query | |
| :param accuracy: Accuracy for computing the winding number with fast winding number method utilizing second-order dipole approximation, default 2.0 | |
| :param threshold: The threshold of the winding number to be considered inside, default 0.5 | |
| """ | |
| ... | |
| def mesh_query_ray(id: uint64, start: vec3f, dir: vec3f, max_t: float32) -> mesh_query_ray_t: | |
| """ | |
| Computes the closest ray hit on the :class:`Mesh` with identifier ``id``. | |
| :param id: The mesh identifier | |
| :param start: The start point of the ray | |
| :param dir: The ray direction (should be normalized) | |
| :param max_t: The maximum distance along the ray to check for intersections | |
| """ | |
| ... | |
| def mesh_query_edge( | |
| id: uint64, | |
| v1: int, | |
| v2: int, | |
| t: float32, | |
| bary_u: float32, | |
| bary_v: float32, | |
| sign: float32, | |
| normal: vec3f, | |
| face: int32, | |
| ) -> bool: | |
| """ | |
| Computes the closest edge hit on the mesh with identifier `id`, returns ``True`` if a point < ``max_t`` is found. | |
| :param id: The mesh identifier | |
| :param v1: The first vertex of the edge | |
| :param v2: The second vertex of the edge | |
| :param t: Returns the distance of the closest hit along the ray | |
| :param bary_u: Returns the barycentric u coordinate of the closest hit | |
| :param bary_v: Returns the barycentric v coordinate of the closest hit | |
| :param sign: Returns a value > 0 if the hit ray hit front of the face, returns < 0 otherwise | |
| :param normal: Returns the face normal | |
| :param face: Returns the index of the hit face | |
| """ | |
| ... | |
| def mesh_query_aabb(id: uint64, lower: vec3f, upper: vec3f) -> mesh_query_aabb_t: | |
| """ | |
| Construct an axis-aligned bounding box query against a :class:`Mesh`. | |
| This query can be used to iterate over all triangles inside a volume. | |
| :param id: The mesh identifier | |
| :param lower: The lower bound of the bounding box in mesh space | |
| :param upper: The upper bound of the bounding box in mesh space | |
| """ | |
| ... | |
| def mesh_query_aabb_next(query: mesh_query_aabb_t, index: int32) -> bool: | |
| """ | |
| Move to the next triangle overlapping the query bounding box. | |
| The index of the current face is stored in ``index``, returns ``False`` if there are no more overlapping triangles. | |
| """ | |
| ... | |
| def mesh_eval_position(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec3f: | |
| """ | |
| Evaluates the position on the :class:`Mesh` given a face index and barycentric coordinates. | |
| """ | |
| ... | |
| def mesh_eval_velocity(id: uint64, face: int32, bary_u: float32, bary_v: float32) -> vec3f: | |
| """ | |
| Evaluates the velocity on the :class:`Mesh` given a face index and barycentric coordinates. | |
| """ | |
| ... | |
| def hash_grid_query(id: uint64, point: vec3f, max_dist: float32) -> hash_grid_query_t: | |
| """ | |
| Construct a point query against a :class:`HashGrid`. This query can be used to iterate over all neighboring points within a fixed radius from the query point. | |
| """ | |
| ... | |
| def hash_grid_query_next(query: hash_grid_query_t, index: int32) -> bool: | |
| """ | |
| Move to the next point in the hash grid query. The index of the current neighbor is stored in ``index``, returns ``False`` | |
| if there are no more neighbors. | |
| """ | |
| ... | |
| def hash_grid_point_id(id: uint64, index: int32) -> int: | |
| """ | |
| Return the index of a point in the :class:`HashGrid`. This can be used to reorder threads such that grid | |
| traversal occurs in a spatially coherent order. | |
| Returns -1 if the :class:`HashGrid` has not been reserved. | |
| """ | |
| ... | |
| def intersect_tri_tri(v0: vec3f, v1: vec3f, v2: vec3f, u0: vec3f, u1: vec3f, u2: vec3f) -> int: | |
| """ | |
| Tests for intersection between two triangles (v0, v1, v2) and (u0, u1, u2) using Moller's method. Returns > 0 if triangles intersect. | |
| """ | |
| ... | |
| def mesh_get(id: uint64) -> Mesh: | |
| """ | |
| Retrieves the mesh given its index. | |
| """ | |
| ... | |
| def mesh_eval_face_normal(id: uint64, face: int32) -> vec3f: | |
| """ | |
| Evaluates the face normal the mesh given a face index. | |
| """ | |
| ... | |
| def mesh_get_point(id: uint64, index: int32) -> vec3f: | |
| """ | |
| Returns the point of the mesh given a index. | |
| """ | |
| ... | |
| def mesh_get_velocity(id: uint64, index: int32) -> vec3f: | |
| """ | |
| Returns the velocity of the mesh given a index. | |
| """ | |
| ... | |
| def mesh_get_index(id: uint64, index: int32) -> int: | |
| """ | |
| Returns the point-index of the mesh given a face-vertex index. | |
| """ | |
| ... | |
| def closest_point_edge_edge(p1: vec3f, q1: vec3f, p2: vec3f, q2: vec3f, epsilon: float32) -> vec3f: | |
| """ | |
| Finds the closest points between two edges. Returns barycentric weights to the points on each edge, as well as the closest distance between the edges. | |
| :param p1: First point of first edge | |
| :param q1: Second point of first edge | |
| :param p2: First point of second edge | |
| :param q2: Second point of second edge | |
| :param epsilon: Zero tolerance for determining if points in an edge are degenerate. | |
| :param out: vec3 output containing (s,t,d), where `s` in [0,1] is the barycentric weight for the first edge, `t` is the barycentric weight for the second edge, and `d` is the distance between the two edges at these two closest points. | |
| """ | |
| ... | |
| def volume_sample_f(id: uint64, uvw: vec3f, sampling_mode: int32) -> float: | |
| """ | |
| Sample the volume given by ``id`` at the volume local-space point ``uvw``. | |
| Interpolation should be :attr:`warp.Volume.CLOSEST` or :attr:`wp.Volume.LINEAR.` | |
| """ | |
| ... | |
| def volume_sample_grad_f(id: uint64, uvw: vec3f, sampling_mode: int32, grad: vec3f) -> float: | |
| """ | |
| Sample the volume and its gradient given by ``id`` at the volume local-space point ``uvw``. | |
| Interpolation should be :attr:`warp.Volume.CLOSEST` or :attr:`wp.Volume.LINEAR.` | |
| """ | |
| ... | |
| def volume_sample_grad_f(id: uint64, uvw: vec3f, sampling_mode: int32, grad: vec3f) -> float: | |
| """ | |
| Sample the volume and its gradient given by ``id`` at the volume local-space point ``uvw``. Interpolation should be ``wp.Volume.CLOSEST``, or ``wp.Volume.LINEAR.`` | |
| """ | |
| ... | |
| def volume_lookup_f(id: uint64, i: int32, j: int32, k: int32) -> float: | |
| """ | |
| Returns the value of voxel with coordinates ``i``, ``j``, ``k``. | |
| If the voxel at this index does not exist, this function returns the background value | |
| """ | |
| ... | |
| def volume_store_f(id: uint64, i: int32, j: int32, k: int32, value: float32): | |
| """ | |
| Store ``value`` at the voxel with coordinates ``i``, ``j``, ``k``. | |
| """ | |
| ... | |
| def volume_sample_v(id: uint64, uvw: vec3f, sampling_mode: int32) -> vec3f: | |
| """ | |
| Sample the vector volume given by ``id`` at the volume local-space point ``uvw``. | |
| Interpolation should be :attr:`warp.Volume.CLOSEST` or :attr:`wp.Volume.LINEAR.` | |
| """ | |
| ... | |
| def volume_lookup_v(id: uint64, i: int32, j: int32, k: int32) -> vec3f: | |
| """ | |
| Returns the vector value of voxel with coordinates ``i``, ``j``, ``k``. | |
| If the voxel at this index does not exist, this function returns the background value. | |
| """ | |
| ... | |
| def volume_store_v(id: uint64, i: int32, j: int32, k: int32, value: vec3f): | |
| """ | |
| Store ``value`` at the voxel with coordinates ``i``, ``j``, ``k``. | |
| """ | |
| ... | |
| def volume_sample_i(id: uint64, uvw: vec3f) -> int: | |
| """ | |
| Sample the :class:`int32` volume given by ``id`` at the volume local-space point ``uvw``. | |
| """ | |
| ... | |
| def volume_lookup_i(id: uint64, i: int32, j: int32, k: int32) -> int: | |
| """ | |
| Returns the :class:`int32` value of voxel with coordinates ``i``, ``j``, ``k``. | |
| If the voxel at this index does not exist, this function returns the background value. | |
| """ | |
| ... | |
| def volume_store_i(id: uint64, i: int32, j: int32, k: int32, value: int32): | |
| """ | |
| Store ``value`` at the voxel with coordinates ``i``, ``j``, ``k``. | |
| """ | |
| ... | |
| def volume_index_to_world(id: uint64, uvw: vec3f) -> vec3f: | |
| """ | |
| Transform a point ``uvw`` defined in volume index space to world space given the volume's intrinsic affine transformation. | |
| """ | |
| ... | |
| def volume_world_to_index(id: uint64, xyz: vec3f) -> vec3f: | |
| """ | |
| Transform a point ``xyz`` defined in volume world space to the volume's index space given the volume's intrinsic affine transformation. | |
| """ | |
| ... | |
| def volume_index_to_world_dir(id: uint64, uvw: vec3f) -> vec3f: | |
| """ | |
| Transform a direction ``uvw`` defined in volume index space to world space given the volume's intrinsic affine transformation. | |
| """ | |
| ... | |
| def volume_world_to_index_dir(id: uint64, xyz: vec3f) -> vec3f: | |
| """ | |
| Transform a direction ``xyz`` defined in volume world space to the volume's index space given the volume's intrinsic affine transformation. | |
| """ | |
| ... | |
| def rand_init(seed: int32) -> uint32: | |
| """ | |
| Initialize a new random number generator given a user-defined seed. Returns a 32-bit integer representing the RNG state. | |
| """ | |
| ... | |
| def rand_init(seed: int32, offset: int32) -> uint32: | |
| """ | |
| Initialize a new random number generator given a user-defined seed and an offset. | |
| This alternative constructor can be useful in parallel programs, where a kernel as a whole should share a seed, | |
| but each thread should generate uncorrelated values. In this case usage should be ``r = rand_init(seed, tid)`` | |
| """ | |
| ... | |
| def randi(state: uint32) -> int: | |
| """ | |
| Return a random integer in the range [0, 2^32). | |
| """ | |
| ... | |
| def randi(state: uint32, min: int32, max: int32) -> int: | |
| """ | |
| Return a random integer between [min, max). | |
| """ | |
| ... | |
| def randf(state: uint32) -> float: | |
| """ | |
| Return a random float between [0.0, 1.0). | |
| """ | |
| ... | |
| def randf(state: uint32, min: float32, max: float32) -> float: | |
| """ | |
| Return a random float between [min, max). | |
| """ | |
| ... | |
| def randn(state: uint32) -> float: | |
| """ | |
| Sample a normal distribution. | |
| """ | |
| ... | |
| def sample_cdf(state: uint32, cdf: Array[float32]) -> int: | |
| """ | |
| Inverse-transform sample a cumulative distribution function. | |
| """ | |
| ... | |
| def sample_triangle(state: uint32) -> vec2f: | |
| """ | |
| Uniformly sample a triangle. Returns sample barycentric coordinates. | |
| """ | |
| ... | |
| def sample_unit_ring(state: uint32) -> vec2f: | |
| """ | |
| Uniformly sample a ring in the xy plane. | |
| """ | |
| ... | |
| def sample_unit_disk(state: uint32) -> vec2f: | |
| """ | |
| Uniformly sample a disk in the xy plane. | |
| """ | |
| ... | |
| def sample_unit_sphere_surface(state: uint32) -> vec3f: | |
| """ | |
| Uniformly sample a unit sphere surface. | |
| """ | |
| ... | |
| def sample_unit_sphere(state: uint32) -> vec3f: | |
| """ | |
| Uniformly sample a unit sphere. | |
| """ | |
| ... | |
| def sample_unit_hemisphere_surface(state: uint32) -> vec3f: | |
| """ | |
| Uniformly sample a unit hemisphere surface. | |
| """ | |
| ... | |
| def sample_unit_hemisphere(state: uint32) -> vec3f: | |
| """ | |
| Uniformly sample a unit hemisphere. | |
| """ | |
| ... | |
| def sample_unit_square(state: uint32) -> vec2f: | |
| """ | |
| Uniformly sample a unit square. | |
| """ | |
| ... | |
| def sample_unit_cube(state: uint32) -> vec3f: | |
| """ | |
| Uniformly sample a unit cube. | |
| """ | |
| ... | |
| def poisson(state: uint32, lam: float32) -> uint32: | |
| """ | |
| Generate a random sample from a Poisson distribution. | |
| :param state: RNG state | |
| :param lam: The expected value of the distribution | |
| """ | |
| ... | |
| def noise(state: uint32, x: float32) -> float: | |
| """ | |
| Non-periodic Perlin-style noise in 1D. | |
| """ | |
| ... | |
| def noise(state: uint32, xy: vec2f) -> float: | |
| """ | |
| Non-periodic Perlin-style noise in 2D. | |
| """ | |
| ... | |
| def noise(state: uint32, xyz: vec3f) -> float: | |
| """ | |
| Non-periodic Perlin-style noise in 3D. | |
| """ | |
| ... | |
| def noise(state: uint32, xyzt: vec4f) -> float: | |
| """ | |
| Non-periodic Perlin-style noise in 4D. | |
| """ | |
| ... | |
| def pnoise(state: uint32, x: float32, px: int32) -> float: | |
| """ | |
| Periodic Perlin-style noise in 1D. | |
| """ | |
| ... | |
| def pnoise(state: uint32, xy: vec2f, px: int32, py: int32) -> float: | |
| """ | |
| Periodic Perlin-style noise in 2D. | |
| """ | |
| ... | |
| def pnoise(state: uint32, xyz: vec3f, px: int32, py: int32, pz: int32) -> float: | |
| """ | |
| Periodic Perlin-style noise in 3D. | |
| """ | |
| ... | |
| def pnoise(state: uint32, xyzt: vec4f, px: int32, py: int32, pz: int32, pt: int32) -> float: | |
| """ | |
| Periodic Perlin-style noise in 4D. | |
| """ | |
| ... | |
| def curlnoise(state: uint32, xy: vec2f, octaves: uint32, lacunarity: float32, gain: float32) -> vec2f: | |
| """ | |
| Divergence-free vector field based on the gradient of a Perlin noise function. | |
| """ | |
| ... | |
| def curlnoise(state: uint32, xyz: vec3f, octaves: uint32, lacunarity: float32, gain: float32) -> vec3f: | |
| """ | |
| Divergence-free vector field based on the curl of three Perlin noise functions. | |
| """ | |
| ... | |
| def curlnoise(state: uint32, xyzt: vec4f, octaves: uint32, lacunarity: float32, gain: float32) -> vec3f: | |
| """ | |
| Divergence-free vector field based on the curl of three Perlin noise functions. | |
| """ | |
| ... | |
| def printf(): | |
| """ | |
| Allows printing formatted strings using C-style format specifiers. | |
| """ | |
| ... | |
| def tid() -> Tuple[int, int]: | |
| """ | |
| Return the current thread indices for a 2D kernel launch. Use ``i,j = wp.tid()`` syntax to retrieve the | |
| coordinates inside the kernel thread grid. This function may not be called from user-defined Warp functions. | |
| """ | |
| ... | |
| def tid() -> Tuple[int, int, int]: | |
| """ | |
| Return the current thread indices for a 3D kernel launch. Use ``i,j,k = wp.tid()`` syntax to retrieve the | |
| coordinates inside the kernel thread grid. This function may not be called from user-defined Warp functions. | |
| """ | |
| ... | |
| def tid() -> Tuple[int, int, int, int]: | |
| """ | |
| Return the current thread indices for a 4D kernel launch. Use ``i,j,k,l = wp.tid()`` syntax to retrieve the | |
| coordinates inside the kernel thread grid. This function may not be called from user-defined Warp functions. | |
| """ | |
| ... | |
| def select(cond: bool, arg1: Any, arg2: Any): | |
| """ | |
| Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2`` | |
| """ | |
| ... | |
| def select(cond: bool, arg1: Any, arg2: Any): | |
| """ | |
| Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2`` | |
| """ | |
| ... | |
| def select(cond: bool, arg1: Any, arg2: Any): | |
| """ | |
| Select between two arguments, if cond is false then return ``arg1``, otherwise return ``arg2`` | |
| """ | |
| ... | |
| def select(cond: int8, arg1: Any, arg2: Any): | |
| """ | |
| Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2`` | |
| """ | |
| ... | |
| def select(cond: uint8, arg1: Any, arg2: Any): | |
| """ | |
| Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2`` | |
| """ | |
| ... | |
| def select(cond: int16, arg1: Any, arg2: Any): | |
| """ | |
| Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2`` | |
| """ | |
| ... | |
| def select(cond: uint16, arg1: Any, arg2: Any): | |
| """ | |
| Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2`` | |
| """ | |
| ... | |
| def select(cond: int32, arg1: Any, arg2: Any): | |
| """ | |
| Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2`` | |
| """ | |
| ... | |
| def select(cond: uint32, arg1: Any, arg2: Any): | |
| """ | |
| Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2`` | |
| """ | |
| ... | |
| def select(cond: int64, arg1: Any, arg2: Any): | |
| """ | |
| Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2`` | |
| """ | |
| ... | |
| def select(cond: uint64, arg1: Any, arg2: Any): | |
| """ | |
| Select between two arguments, if ``cond`` is ``False`` then return ``arg1``, otherwise return ``arg2`` | |
| """ | |
| ... | |
| def select(arr: Array[Any], arg1: Any, arg2: Any): | |
| """ | |
| Select between two arguments, if ``arr`` is null then return ``arg1``, otherwise return ``arg2`` | |
| """ | |
| ... | |
| def atomic_add(a: Array[Any], i: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto ``a[i]``. | |
| """ | |
| ... | |
| def atomic_add(a: Array[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto ``a[i,j]``. | |
| """ | |
| ... | |
| def atomic_add(a: Array[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto ``a[i,j,k]``. | |
| """ | |
| ... | |
| def atomic_add(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto ``a[i,j,k,l]``. | |
| """ | |
| ... | |
| def atomic_add(a: FabricArray[Any], i: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto ``a[i]``. | |
| """ | |
| ... | |
| def atomic_add(a: FabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto ``a[i,j]``. | |
| """ | |
| ... | |
| def atomic_add(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto ``a[i,j,k]``. | |
| """ | |
| ... | |
| def atomic_add(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto ``a[i,j,k,l]``. | |
| """ | |
| ... | |
| def atomic_add(a: IndexedFabricArray[Any], i: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto ``a[i]``. | |
| """ | |
| ... | |
| def atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto ``a[i,j]``. | |
| """ | |
| ... | |
| def atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto ``a[i,j,k]``. | |
| """ | |
| ... | |
| def atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto ``a[i,j,k,l]``. | |
| """ | |
| ... | |
| def atomic_add(a: FabricArray[Any], i: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto the array at location given by index. | |
| """ | |
| ... | |
| def atomic_add(a: FabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto the array at location given by indices. | |
| """ | |
| ... | |
| def atomic_add(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto the array at location given by indices. | |
| """ | |
| ... | |
| def atomic_add(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto the array at location given by indices. | |
| """ | |
| ... | |
| def atomic_add(a: IndexedFabricArray[Any], i: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto the array at location given by index. | |
| """ | |
| ... | |
| def atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto the array at location given by indices. | |
| """ | |
| ... | |
| def atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto the array at location given by indices. | |
| """ | |
| ... | |
| def atomic_add(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Atomically add ``value`` onto the array at location given by indices. | |
| """ | |
| ... | |
| def atomic_sub(a: Array[Any], i: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto ``a[i]``. | |
| """ | |
| ... | |
| def atomic_sub(a: Array[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto ``a[i,j]``. | |
| """ | |
| ... | |
| def atomic_sub(a: Array[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto ``a[i,j,k]``. | |
| """ | |
| ... | |
| def atomic_sub(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto ``a[i,j,k,l]``. | |
| """ | |
| ... | |
| def atomic_sub(a: FabricArray[Any], i: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto ``a[i]``. | |
| """ | |
| ... | |
| def atomic_sub(a: FabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto ``a[i,j]``. | |
| """ | |
| ... | |
| def atomic_sub(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto ``a[i,j,k]``. | |
| """ | |
| ... | |
| def atomic_sub(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto ``a[i,j,k,l]``. | |
| """ | |
| ... | |
| def atomic_sub(a: IndexedFabricArray[Any], i: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto ``a[i]``. | |
| """ | |
| ... | |
| def atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto ``a[i,j]``. | |
| """ | |
| ... | |
| def atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto ``a[i,j,k]``. | |
| """ | |
| ... | |
| def atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto ``a[i,j,k,l]``. | |
| """ | |
| ... | |
| def atomic_sub(a: FabricArray[Any], i: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto the array at location given by index. | |
| """ | |
| ... | |
| def atomic_sub(a: FabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto the array at location given by indices. | |
| """ | |
| ... | |
| def atomic_sub(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto the array at location given by indices. | |
| """ | |
| ... | |
| def atomic_sub(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto the array at location given by indices. | |
| """ | |
| ... | |
| def atomic_sub(a: IndexedFabricArray[Any], i: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto the array at location given by index. | |
| """ | |
| ... | |
| def atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto the array at location given by indices. | |
| """ | |
| ... | |
| def atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto the array at location given by indices. | |
| """ | |
| ... | |
| def atomic_sub(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Atomically subtract ``value`` onto the array at location given by indices. | |
| """ | |
| ... | |
| def atomic_min(a: Array[Any], i: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``a[i]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: Array[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``a[i,j]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: Array[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``a[i,j,k]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``a[i,j,k,l]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: FabricArray[Any], i: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``a[i]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: FabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``a[i,j]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``a[i,j,k]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``a[i,j,k,l]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: IndexedFabricArray[Any], i: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``a[i]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``a[i,j]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``a[i,j,k]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``a[i,j,k,l]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: FabricArray[Any], i: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: FabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: IndexedFabricArray[Any], i: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_min(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Compute the minimum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: Array[Any], i: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``a[i]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: Array[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``a[i,j]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: Array[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``a[i,j,k]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: Array[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``a[i,j,k,l]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: FabricArray[Any], i: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``a[i]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: FabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``a[i,j]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``a[i,j,k]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``a[i,j,k,l]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: IndexedFabricArray[Any], i: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``a[i]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``a[i,j]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``a[i,j,k]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``a[i,j,k,l]`` and atomically update the array. | |
| Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: FabricArray[Any], i: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: FabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: FabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: FabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: IndexedFabricArray[Any], i: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def atomic_max(a: IndexedFabricArray[Any], i: int32, j: int32, k: int32, l: int32, value: Any): | |
| """ | |
| Compute the maximum of ``value`` and ``array[index]`` and atomically update the array. Note that for vectors and matrices the operation is only atomic on a per-component basis. | |
| """ | |
| ... | |
| def lerp(a: Float, b: Float, t: Float) -> Float: | |
| """ | |
| Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t`` | |
| """ | |
| ... | |
| def lerp(a: Vector[Any, Float], b: Vector[Any, Float], t: Float) -> Vector[Any, Float]: | |
| """ | |
| Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t`` | |
| """ | |
| ... | |
| def lerp(a: Matrix[Any, Any, Float], b: Matrix[Any, Any, Float], t: Float) -> Matrix[Any, Any, Float]: | |
| """ | |
| Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t`` | |
| """ | |
| ... | |
| def lerp(a: Quaternion[Float], b: Quaternion[Float], t: Float) -> Quaternion[Float]: | |
| """ | |
| Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t`` | |
| """ | |
| ... | |
| def lerp(a: Transformation[Float], b: Transformation[Float], t: Float) -> Transformation[Float]: | |
| """ | |
| Linearly interpolate two values ``a`` and ``b`` using factor ``t``, computed as ``a*(1-t) + b*t`` | |
| """ | |
| ... | |
| def smoothstep(edge0: Float, edge1: Float, x: Float) -> Float: | |
| """ | |
| Smoothly interpolate between two values ``edge0`` and ``edge1`` using a factor ``x``, | |
| and return a result between 0 and 1 using a cubic Hermite interpolation after clamping. | |
| """ | |
| ... | |
| def expect_near(arg1: Float, arg2: Float, tolerance: Float): | |
| """ | |
| Prints an error to stdout if ``arg1`` and ``arg2`` are not closer than tolerance in magnitude | |
| """ | |
| ... | |
| def expect_near(arg1: vec3f, arg2: vec3f, tolerance: float32): | |
| """ | |
| Prints an error to stdout if any element of ``arg1`` and ``arg2`` are not closer than tolerance in magnitude | |
| """ | |
| ... | |
| def lower_bound(arr: Array[Scalar], value: Scalar) -> int: | |
| """ | |
| Search a sorted array ``arr`` for the closest element greater than or equal to ``value``. | |
| """ | |
| ... | |
| def lower_bound(arr: Array[Scalar], arr_begin: int32, arr_end: int32, value: Scalar) -> int: | |
| """ | |
| Search a sorted array ``arr`` in the range [arr_begin, arr_end) for the closest element greater than or equal to ``value``. | |
| """ | |
| ... | |
| def lower_bound(arr: Array[Scalar], arr_begin: int32, arr_end: int32, value: Scalar) -> int: | |
| """ | |
| Search a sorted array range [arr_begin, arr_end) for the closest element greater than or equal to value. | |
| """ | |
| ... | |
| def add(x: Scalar, y: Scalar) -> Scalar: | |
| """ """ | |
| ... | |
| def add(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]: | |
| """ """ | |
| ... | |
| def add(x: Quaternion[Scalar], y: Quaternion[Scalar]) -> Quaternion[Scalar]: | |
| """ """ | |
| ... | |
| def add(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]: | |
| """ """ | |
| ... | |
| def add(x: Transformation[Scalar], y: Transformation[Scalar]) -> Transformation[Scalar]: | |
| """ """ | |
| ... | |
| def sub(x: Scalar, y: Scalar) -> Scalar: | |
| """ """ | |
| ... | |
| def sub(x: Vector[Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]: | |
| """ """ | |
| ... | |
| def sub(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]: | |
| """ """ | |
| ... | |
| def sub(x: Quaternion[Scalar], y: Quaternion[Scalar]) -> Quaternion[Scalar]: | |
| """ """ | |
| ... | |
| def sub(x: Transformation[Scalar], y: Transformation[Scalar]) -> Transformation[Scalar]: | |
| """ """ | |
| ... | |
| def bit_and(x: Int, y: Int) -> Int: | |
| """ """ | |
| ... | |
| def bit_or(x: Int, y: Int) -> Int: | |
| """ """ | |
| ... | |
| def bit_xor(x: Int, y: Int) -> Int: | |
| """ """ | |
| ... | |
| def lshift(x: Int, y: Int) -> Int: | |
| """ """ | |
| ... | |
| def rshift(x: Int, y: Int) -> Int: | |
| """ """ | |
| ... | |
| def invert(x: Int) -> Int: | |
| """ """ | |
| ... | |
| def mul(x: Scalar, y: Scalar) -> Scalar: | |
| """ """ | |
| ... | |
| def mul(x: Vector[Any, Scalar], y: Scalar) -> Vector[Any, Scalar]: | |
| """ """ | |
| ... | |
| def mul(x: Scalar, y: Vector[Any, Scalar]) -> Vector[Any, Scalar]: | |
| """ """ | |
| ... | |
| def mul(x: Quaternion[Scalar], y: Scalar) -> Quaternion[Scalar]: | |
| """ """ | |
| ... | |
| def mul(x: Scalar, y: Quaternion[Scalar]) -> Quaternion[Scalar]: | |
| """ """ | |
| ... | |
| def mul(x: Quaternion[Scalar], y: Quaternion[Scalar]) -> Quaternion[Scalar]: | |
| """ """ | |
| ... | |
| def mul(x: Scalar, y: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]: | |
| """ """ | |
| ... | |
| def mul(x: Matrix[Any, Any, Scalar], y: Scalar) -> Matrix[Any, Any, Scalar]: | |
| """ """ | |
| ... | |
| def mul(x: Matrix[Any, Any, Scalar], y: Vector[Any, Scalar]) -> Vector[Any, Scalar]: | |
| """ """ | |
| ... | |
| def mul(x: Matrix[Any, Any, Scalar], y: Matrix[Any, Any, Scalar]): | |
| """ """ | |
| ... | |
| def mul(x: Transformation[Scalar], y: Transformation[Scalar]) -> Transformation[Scalar]: | |
| """ """ | |
| ... | |
| def mul(x: Scalar, y: Transformation[Scalar]) -> Transformation[Scalar]: | |
| """ """ | |
| ... | |
| def mul(x: Transformation[Scalar], y: Scalar) -> Transformation[Scalar]: | |
| """ """ | |
| ... | |
| def mod(x: Scalar, y: Scalar) -> Scalar: | |
| """ """ | |
| ... | |
| def div(x: Scalar, y: Scalar) -> Scalar: | |
| """ """ | |
| ... | |
| def div(x: Vector[Any, Scalar], y: Scalar) -> Vector[Any, Scalar]: | |
| """ """ | |
| ... | |
| def div(x: Matrix[Any, Any, Scalar], y: Scalar) -> Matrix[Any, Any, Scalar]: | |
| """ """ | |
| ... | |
| def div(x: Quaternion[Scalar], y: Scalar) -> Quaternion[Scalar]: | |
| """ """ | |
| ... | |
| def floordiv(x: Scalar, y: Scalar) -> Scalar: | |
| """ """ | |
| ... | |
| def pos(x: Scalar) -> Scalar: | |
| """ """ | |
| ... | |
| def pos(x: Vector[Any, Scalar]) -> Vector[Any, Scalar]: | |
| """ """ | |
| ... | |
| def pos(x: Quaternion[Scalar]) -> Quaternion[Scalar]: | |
| """ """ | |
| ... | |
| def pos(x: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]: | |
| """ """ | |
| ... | |
| def neg(x: Scalar) -> Scalar: | |
| """ """ | |
| ... | |
| def neg(x: Vector[Any, Scalar]) -> Vector[Any, Scalar]: | |
| """ """ | |
| ... | |
| def neg(x: Quaternion[Scalar]) -> Quaternion[Scalar]: | |
| """ """ | |
| ... | |
| def neg(x: Matrix[Any, Any, Scalar]) -> Matrix[Any, Any, Scalar]: | |
| """ """ | |
| ... | |
| def unot(b: bool) -> bool: | |
| """ """ | |
| ... | |
| def unot(b: bool) -> bool: | |
| """ """ | |
| ... | |
| def unot(b: int8) -> bool: | |
| """ """ | |
| ... | |
| def unot(b: uint8) -> bool: | |
| """ """ | |
| ... | |
| def unot(b: int16) -> bool: | |
| """ """ | |
| ... | |
| def unot(b: uint16) -> bool: | |
| """ """ | |
| ... | |
| def unot(b: int32) -> bool: | |
| """ """ | |
| ... | |
| def unot(b: uint32) -> bool: | |
| """ """ | |
| ... | |
| def unot(b: int64) -> bool: | |
| """ """ | |
| ... | |
| def unot(b: uint64) -> bool: | |
| """ """ | |
| ... | |
| def unot(a: Array[Any]) -> bool: | |
| """ """ | |
| ... | |